Eigen::internal Namespace Reference

Namespaces
namespace	detail
namespace	group_theory
namespace	std_fallback

Classes
struct	Abs
struct	abs2_impl
struct	abs2_impl_default
struct	abs2_impl_default< Scalar, true >
struct	abs2_retval
struct	Abs< Num, false >
struct	abs_knowing_score
struct	abs_knowing_score< Scalar, typename scalar_score_coeff_op< Scalar >::Score_is_abs >
struct	accessors_level
struct	accurate_log2
struct	accurate_log2< double >
struct	accurate_log2< float >
struct	add_assign_op
struct	add_const
struct	add_const< T & >
struct	add_const_on_value_type
struct	add_const_on_value_type< T & >
struct	add_const_on_value_type< T * >
struct	add_const_on_value_type< T *const >
struct	add_const_on_value_type< T const *const >
struct	add_const_on_value_type_if_arithmetic
class	aligned_stack_memory_handler
struct	aligned_storage
struct	all_indices_known_statically_impl
struct	all_indices_known_statically_impl< const DimensionList< Index, Rank > >
struct	all_indices_known_statically_impl< DimensionList< Index, Rank > >
struct	all_t
struct	all_unroller
struct	all_unroller< Derived, 0, Rows >
struct	all_unroller< Derived, Dynamic, Rows >
struct	AllRange
struct	always_void
class	AmbiVector
struct	AndReducer
struct	any_unroller
struct	any_unroller< Derived, 0, Rows >
struct	any_unroller< Derived, Dynamic, Rows >
struct	apply_op_from_left
struct	apply_op_from_right
struct	apply_rotation_in_the_plane_selector
struct	apply_rotation_in_the_plane_selector< Scalar, OtherScalar, SizeAtCompileTime, MinAlignment, true >
struct	are_inner_most_dims
struct	arg_default_impl
struct	arg_default_impl< Scalar, true >
struct	arg_impl
struct	arg_retval
struct	ArgMaxTupleReducer
struct	ArgMinTupleReducer
struct	arpack_wrapper
struct	arpack_wrapper< double, double >
struct	arpack_wrapper< float, float >
struct	array_size
struct	array_size< const DimensionList< Index, Rank > >
struct	array_size< const DSizes< DenseIndex, NumDims > >
struct	array_size< const Sizes< Indices... > >
struct	array_size< const T(&)[N]>
struct	array_size< DimensionList< Index, Rank > >
struct	array_size< DSizes< DenseIndex, NumDims > >
struct	array_size< Sizes< Indices... > >
struct	array_size< T(&)[N]>
struct	array_size< T, typename internal::enable_if<((T::SizeAtCompileTime &0)==0)>::type >
struct	aseq_negate
struct	aseq_negate< FixedInt< DynamicIndex > >
struct	aseq_negate< FixedInt< N > >
struct	aseq_negate< Index >
struct	aseq_reverse_first_type
struct	aseq_reverse_first_type< FirstType, SizeType, IncrType, false, true >
struct	aseq_reverse_first_type< FirstType, SizeType, IncrType, true, false >
struct	aseq_reverse_first_type< FirstType, SizeType, IncrType, true, true >
struct	aseq_reverse_first_type_aux
struct	aseq_reverse_first_type_aux< SizeType, IncrType, typename internal::enable_if< bool((SizeType::value+IncrType::value)|0x1)>::type >
struct	assign_op
struct	assign_op< DstScalar, void >
struct	Assignment
struct	Assignment< DstXprType, CwiseBinaryOp< internal::scalar_product_op< ScalarBis, Scalar >, const CwiseNullaryOp< internal::scalar_constant_op< ScalarBis >, Plain >, const Product< Lhs, Rhs, DefaultProduct > >, AssignFunc, Dense2Dense >
struct	Assignment< DstXprType, Homogeneous< ArgType, Horizontal >, internal::assign_op< Scalar, typename ArgType::Scalar >, Dense2Dense >
struct	Assignment< DstXprType, Homogeneous< ArgType, Vertical >, internal::assign_op< Scalar, typename ArgType::Scalar >, Dense2Dense >
struct	Assignment< DstXprType, Inverse< ColPivHouseholderQR< MatrixType > >, internal::assign_op< typename DstXprType::Scalar, typename ColPivHouseholderQR< MatrixType >::Scalar >, Dense2Dense >
struct	Assignment< DstXprType, Inverse< CompleteOrthogonalDecomposition< MatrixType > >, internal::assign_op< typename DstXprType::Scalar, typename CompleteOrthogonalDecomposition< MatrixType >::Scalar >, Dense2Dense >
struct	Assignment< DstXprType, Inverse< FullPivHouseholderQR< MatrixType > >, internal::assign_op< typename DstXprType::Scalar, typename FullPivHouseholderQR< MatrixType >::Scalar >, Dense2Dense >
struct	Assignment< DstXprType, Inverse< FullPivLU< MatrixType > >, internal::assign_op< typename DstXprType::Scalar, typename FullPivLU< MatrixType >::Scalar >, Dense2Dense >
struct	Assignment< DstXprType, Inverse< PartialPivLU< MatrixType > >, internal::assign_op< typename DstXprType::Scalar, typename PartialPivLU< MatrixType >::Scalar >, Dense2Dense >
struct	Assignment< DstXprType, Inverse< XprType >, internal::assign_op< typename DstXprType::Scalar, typename XprType::Scalar >, Dense2Dense >
struct	Assignment< DstXprType, Product< Lhs, Rhs, AliasFreeProduct >, internal::add_assign_op< typename DstXprType::Scalar, typename Product< Lhs, Rhs, AliasFreeProduct >::Scalar >, Sparse2Dense >
struct	Assignment< DstXprType, Product< Lhs, Rhs, AliasFreeProduct >, internal::assign_op< typename DstXprType::Scalar, typename Product< Lhs, Rhs, AliasFreeProduct >::Scalar >, Sparse2Dense >
struct	Assignment< DstXprType, Product< Lhs, Rhs, AliasFreeProduct >, internal::sub_assign_op< typename DstXprType::Scalar, typename Product< Lhs, Rhs, AliasFreeProduct >::Scalar >, Sparse2Dense >
struct	Assignment< DstXprType, Product< Lhs, Rhs, DefaultProduct >, internal::add_assign_op< Scalar, typename Product< Lhs, Rhs, DefaultProduct >::Scalar >, Dense2Triangular >
struct	Assignment< DstXprType, Product< Lhs, Rhs, DefaultProduct >, internal::assign_op< Scalar, typename Product< Lhs, Rhs, DefaultProduct >::Scalar >, Dense2Triangular >
struct	Assignment< DstXprType, Product< Lhs, Rhs, DefaultProduct >, internal::sub_assign_op< Scalar, typename Product< Lhs, Rhs, DefaultProduct >::Scalar >, Dense2Triangular >
struct	Assignment< DstXprType, Product< Lhs, Rhs, Options >, internal::add_assign_op< Scalar, Scalar >, Dense2Dense, typename enable_if<(Options==DefaultProduct||Options==AliasFreeProduct)>::type >
struct	Assignment< DstXprType, Product< Lhs, Rhs, Options >, internal::assign_op< Scalar, Scalar >, Dense2Dense, typename enable_if<(Options==DefaultProduct||Options==AliasFreeProduct)>::type >
struct	Assignment< DstXprType, Product< Lhs, Rhs, Options >, internal::sub_assign_op< Scalar, Scalar >, Dense2Dense, typename enable_if<(Options==DefaultProduct||Options==AliasFreeProduct)>::type >
struct	Assignment< DstXprType, Solve< CwiseUnaryOp< internal::scalar_conjugate_op< typename DecType::Scalar >, const Transpose< const DecType > >, RhsType >, internal::assign_op< Scalar, Scalar >, Dense2Dense >
struct	Assignment< DstXprType, Solve< DecType, RhsType >, internal::assign_op< Scalar, Scalar >, Dense2Dense >
struct	Assignment< DstXprType, Solve< DecType, RhsType >, internal::assign_op< Scalar, Scalar >, Sparse2Sparse >
struct	Assignment< DstXprType, Solve< Transpose< const DecType >, RhsType >, internal::assign_op< Scalar, Scalar >, Dense2Dense >
struct	Assignment< DstXprType, SparseQRMatrixQReturnType< SparseQRType >, internal::assign_op< typename DstXprType::Scalar, typename DstXprType::Scalar >, Sparse2Dense >
struct	Assignment< DstXprType, SparseQRMatrixQReturnType< SparseQRType >, internal::assign_op< typename DstXprType::Scalar, typename DstXprType::Scalar >, Sparse2Sparse >
struct	Assignment< DstXprType, SparseSymmetricPermutationProduct< MatrixType, Mode >, internal::assign_op< Scalar, typename MatrixType::Scalar >, Sparse2Sparse >
struct	Assignment< DstXprType, SrcXprType, Functor, Dense2Dense, Weak >
struct	Assignment< DstXprType, SrcXprType, Functor, Dense2Triangular >
struct	Assignment< DstXprType, SrcXprType, Functor, Diagonal2Dense >
struct	Assignment< DstXprType, SrcXprType, Functor, Diagonal2Sparse >
struct	Assignment< DstXprType, SrcXprType, Functor, EigenBase2EigenBase, Weak >
struct	Assignment< DstXprType, SrcXprType, Functor, Sparse2Dense, Weak >
struct	Assignment< DstXprType, SrcXprType, Functor, Sparse2Sparse >
struct	Assignment< DstXprType, SrcXprType, Functor, SparseSelfAdjoint2Sparse >
struct	Assignment< DstXprType, SrcXprType, Functor, Triangular2Dense >
struct	Assignment< DstXprType, SrcXprType, Functor, Triangular2Triangular >
struct	assignment_from_dense_op_sparse
struct	assignment_from_xpr_op_product
struct	AssignmentKind
struct	AssignmentKind< DenseShape, BandShape >
struct	AssignmentKind< DenseShape, DenseShape >
struct	AssignmentKind< DenseShape, DiagonalShape >
struct	AssignmentKind< DenseShape, HomogeneousShape >
struct	AssignmentKind< DenseShape, PermutationShape >
struct	AssignmentKind< DenseShape, SparseShape >
struct	AssignmentKind< DenseShape, SparseTriangularShape >
struct	AssignmentKind< DenseShape, TriangularShape >
struct	AssignmentKind< SparseSelfAdjointShape, SparseShape >
struct	AssignmentKind< SparseShape, DiagonalShape >
struct	AssignmentKind< SparseShape, SparseSelfAdjointShape >
struct	AssignmentKind< SparseShape, SparseShape >
struct	AssignmentKind< SparseShape, SparseTriangularShape >
struct	AssignmentKind< TriangularShape, DenseShape >
struct	AssignmentKind< TriangularShape, TriangularShape >
struct	auto_diff_special_op
struct	auto_diff_special_op< DerivativeType, false >
struct	auto_diff_special_op< DerivativeType, true >
class	BandMatrix
	Represents a rectangular matrix with a banded storage. More...
class	BandMatrixBase
class	BandMatrixWrapper
struct	BandShape
class	BaseTensorContractionMapper
class	BaseTensorContractionMapper< Scalar, Index, side, Tensor, nocontract_t, contract_t, 1, inner_dim_contiguous, inner_dim_reordered, Alignment, MakePointer_ >
struct	bessel_i0_impl
struct	bessel_i0_retval
struct	bessel_i0e_impl
struct	bessel_i0e_retval
struct	bessel_i1_impl
struct	bessel_i1_retval
struct	bessel_i1e_impl
struct	bessel_i1e_retval
struct	bessel_j0_impl
struct	bessel_j0_retval
struct	bessel_j1_impl
struct	bessel_j1_retval
struct	bessel_k0_impl
struct	bessel_k0_retval
struct	bessel_k0e_impl
struct	bessel_k0e_retval
struct	bessel_k1_impl
struct	bessel_k1_retval
struct	bessel_k1e_impl
struct	bessel_k1e_retval
struct	bessel_y0_impl
struct	bessel_y0_retval
struct	bessel_y1_impl
struct	bessel_y1_retval
struct	betainc_impl
struct	betainc_retval
struct	binary_evaluator
struct	binary_evaluator< CwiseBinaryOp< BinaryOp, Lhs, Rhs >, IndexBased, IndexBased >
struct	binary_evaluator< CwiseBinaryOp< BinaryOp, Lhs, Rhs >, IndexBased, IteratorBased >
struct	binary_evaluator< CwiseBinaryOp< BinaryOp, Lhs, Rhs >, IteratorBased, IndexBased >
struct	binary_evaluator< CwiseBinaryOp< BinaryOp, Lhs, Rhs >, IteratorBased, IteratorBased >
struct	binary_evaluator< CwiseBinaryOp< scalar_boolean_and_op, Lhs, Rhs >, IndexBased, IteratorBased >
struct	binary_evaluator< CwiseBinaryOp< scalar_boolean_and_op, Lhs, Rhs >, IteratorBased, IndexBased >
struct	binary_evaluator< CwiseBinaryOp< scalar_boolean_and_op, Lhs, Rhs >, IteratorBased, IteratorBased >
struct	binary_evaluator< CwiseBinaryOp< scalar_product_op< T1, T2 >, Lhs, Rhs >, IndexBased, IteratorBased >
struct	binary_evaluator< CwiseBinaryOp< scalar_product_op< T1, T2 >, Lhs, Rhs >, IteratorBased, IndexBased >
struct	binary_evaluator< CwiseBinaryOp< scalar_product_op< T1, T2 >, Lhs, Rhs >, IteratorBased, IteratorBased >
struct	binary_evaluator< CwiseBinaryOp< scalar_quotient_op< T1, T2 >, Lhs, Rhs >, IteratorBased, IndexBased >
struct	binary_op_base
struct	binary_result_of_select
struct	binary_result_of_select< Func, ArgType0, ArgType1, sizeof(has_std_result_type)>
struct	binary_result_of_select< Func, ArgType0, ArgType1, sizeof(has_tr1_result)>
struct	binary_sparse_evaluator
struct	bind1st_op
struct	bind2nd_op
struct	bit_and
struct	bit_andnot
struct	bit_not
struct	bit_or
struct	bit_xor
struct	bitwise_helper
struct	bitwise_helper< T, typename internal::enable_if< is_scalar< T >::value &&(NumTraits< T >::IsInteger||NumTraits< T >::RequireInitialization)>::type >
class	blas_data_mapper
class	blas_data_mapper< Scalar, Index, StorageOrder, AlignmentType, 1 >
struct	blas_traits
struct	blas_traits< const T >
struct	blas_traits< CwiseBinaryOp< scalar_product_op< Scalar >, const CwiseNullaryOp< scalar_constant_op< Scalar >, Plain >, NestedXpr > >
struct	blas_traits< CwiseBinaryOp< scalar_product_op< Scalar >, const CwiseNullaryOp< scalar_constant_op< Scalar >, Plain1 >, const CwiseNullaryOp< scalar_constant_op< Scalar >, Plain2 > > >
struct	blas_traits< CwiseBinaryOp< scalar_product_op< Scalar >, NestedXpr, const CwiseNullaryOp< scalar_constant_op< Scalar >, Plain > > >
struct	blas_traits< CwiseUnaryOp< scalar_conjugate_op< Scalar >, NestedXpr > >
struct	blas_traits< CwiseUnaryOp< scalar_opposite_op< Scalar >, NestedXpr > >
struct	blas_traits< Transpose< NestedXpr > >
class	BlasLinearMapper
class	BlasLinearMapper< Scalar, Index, AlignmentType >
class	BlasVectorMapper
struct	block_evaluator
struct	block_evaluator< ArgType, BlockRows, BlockCols, InnerPanel, false >
struct	block_evaluator< ArgType, BlockRows, BlockCols, InnerPanel, true >
class	BlockImpl_dense
class	BlockImpl_dense< XprType, BlockRows, BlockCols, InnerPanel, true >
struct	bool_constant
struct	bool_constant< false >
struct	bool_constant< true >
struct	bytewise_bitwise_helper
struct	CacheSizes
struct	cast_impl
struct	cast_impl< OldType, NewType, typename internal::enable_if< !NumTraits< OldType >::IsComplex &&NumTraits< NewType >::IsComplex >::type >
struct	cast_impl< Real, NewType >
struct	cast_impl< Real, std::complex< Real > >
struct	cast_return_type
struct	cephes_helper
struct	cephes_helper< double >
struct	cephes_helper< float >
struct	check_rows_cols_for_overflow
struct	check_rows_cols_for_overflow< Dynamic >
struct	check_transpose_aliasing_compile_time_selector
struct	check_transpose_aliasing_compile_time_selector< DestIsTransposed, CwiseBinaryOp< BinOp, DerivedA, DerivedB > >
struct	check_transpose_aliasing_run_time_selector
struct	check_transpose_aliasing_run_time_selector< Scalar, DestIsTransposed, CwiseBinaryOp< BinOp, DerivedA, DerivedB > >
struct	checkTransposeAliasing_impl
struct	checkTransposeAliasing_impl< Derived, OtherDerived, false >
struct	cholmod_configure_matrix
struct	cholmod_configure_matrix< double >
struct	cholmod_configure_matrix< std::complex< double > >
struct	cleanup_index_type
struct	cleanup_index_type< FixedInt< N >(*)(), DynamicKey >
struct	cleanup_index_type< T, DynamicKey, typename internal::enable_if< internal::is_integral< T >::value >::type >
struct	cleanup_index_type< VariableAndFixedInt< DynamicKey >, DynamicKey >
struct	cleanup_index_type< VariableAndFixedInt< N >, DynamicKey >
struct	cleanup_seq_incr
struct	coeff_visitor
struct	CoeffConv
struct	CoeffConv< SrcType, TargetType, true >
struct	CoeffLoader
struct	CoeffLoader< Tensor, true, MakePointer_ >
struct	column_dfs_traits
struct	combine_scalar_factors_impl
struct	combine_scalar_factors_impl< bool, Lhs, Rhs >
class	companion
struct	complex_schur_reduce_to_hessenberg
struct	complex_schur_reduce_to_hessenberg< MatrixType, false >
class	CompressedStorage
struct	compute_default_alignment
struct	compute_default_alignment< T, Dynamic >
struct	compute_default_alignment_helper
struct	compute_inverse
struct	compute_inverse< MatrixType, ResultType, 1 >
struct	compute_inverse< MatrixType, ResultType, 2 >
struct	compute_inverse< MatrixType, ResultType, 3 >
struct	compute_inverse< MatrixType, ResultType, 4 >
struct	compute_inverse_and_det_with_check
struct	compute_inverse_and_det_with_check< MatrixType, ResultType, 1 >
struct	compute_inverse_and_det_with_check< MatrixType, ResultType, 2 >
struct	compute_inverse_and_det_with_check< MatrixType, ResultType, 3 >
struct	compute_inverse_and_det_with_check< MatrixType, ResultType, 4 >
struct	compute_inverse_size4
struct	compute_inverse_size4< Architecture::Target, double, MatrixType, ResultType >
struct	compute_inverse_size4< Architecture::Target, float, MatrixType, ResultType >
class	compute_matrix_flags
class	compute_tensor_flags
struct	concat
struct	concat< numeric_list< T, as... >, numeric_list< T, bs... > >
struct	concat< type_list< as... >, type_list< bs... > >
struct	conditional
struct	conditional< false, Then, Else >
struct	conj_default_impl
struct	conj_default_impl< Scalar, true >
struct	conj_expr_if
struct	conj_helper
struct	conj_helper< LhsScalar, RhsScalar, true, true >
struct	conj_helper< Packet, Packet, ConjLhs, ConjRhs >
struct	conj_helper< Packet, Packet, true, true >
struct	conj_helper< Packet4cd, Packet4cd, false, true >
struct	conj_helper< Packet4cd, Packet4cd, true, false >
struct	conj_helper< Packet4cd, Packet4cd, true, true >
struct	conj_if
struct	conj_if< false >
struct	conj_if< true >
struct	conj_impl
struct	conj_retval
struct	conservative_resize_like_impl
struct	conservative_resize_like_impl< Derived, OtherDerived, true >
struct	conservative_sparse_sparse_product_selector
struct	conservative_sparse_sparse_product_selector< Lhs, Rhs, ResultType, ColMajor, ColMajor, ColMajor >
struct	conservative_sparse_sparse_product_selector< Lhs, Rhs, ResultType, ColMajor, ColMajor, RowMajor >
struct	conservative_sparse_sparse_product_selector< Lhs, Rhs, ResultType, ColMajor, RowMajor, ColMajor >
struct	conservative_sparse_sparse_product_selector< Lhs, Rhs, ResultType, ColMajor, RowMajor, RowMajor >
struct	conservative_sparse_sparse_product_selector< Lhs, Rhs, ResultType, RowMajor, ColMajor, ColMajor >
struct	conservative_sparse_sparse_product_selector< Lhs, Rhs, ResultType, RowMajor, ColMajor, RowMajor >
struct	conservative_sparse_sparse_product_selector< Lhs, Rhs, ResultType, RowMajor, RowMajor, ColMajor >
struct	conservative_sparse_sparse_product_selector< Lhs, Rhs, ResultType, RowMajor, RowMajor, RowMajor >
class	const_blas_data_mapper
struct	constructor_without_unaligned_array_assert
struct	contained_in_list
struct	contained_in_list< test, check_against, h_list, true >
struct	contained_in_list< test, check_against, type_list< a, as... >, false >
struct	contained_in_list< test, check_against, type_list< EIGEN_TPL_PP_SPEC_HACK_USE(empty)>, false >
struct	contained_in_list_gf
struct	contained_in_list_gf< test, check_against, h_list, default_flags, true, last_check_flags >
struct	contained_in_list_gf< test, check_against, type_list< a, as... >, default_flags, false, last_check_flags >
struct	contained_in_list_gf< test, check_against, type_list< EIGEN_TPL_PP_SPEC_HACK_USE(empty)>, default_flags, false, last_check_flags >
struct	copy_using_evaluator_DefaultTraversal_CompleteUnrolling
struct	copy_using_evaluator_DefaultTraversal_CompleteUnrolling< Kernel, Stop, Stop >
struct	copy_using_evaluator_DefaultTraversal_InnerUnrolling
struct	copy_using_evaluator_DefaultTraversal_InnerUnrolling< Kernel, Stop, Stop >
struct	copy_using_evaluator_innervec_CompleteUnrolling
struct	copy_using_evaluator_innervec_CompleteUnrolling< Kernel, Stop, Stop >
struct	copy_using_evaluator_innervec_InnerUnrolling
struct	copy_using_evaluator_innervec_InnerUnrolling< Kernel, Stop, Stop, SrcAlignment, DstAlignment >
struct	copy_using_evaluator_LinearTraversal_CompleteUnrolling
struct	copy_using_evaluator_LinearTraversal_CompleteUnrolling< Kernel, Stop, Stop >
struct	copy_using_evaluator_traits
struct	cross3_impl
struct	cross3_impl< Architecture::Target, VectorLhs, VectorRhs, float, true >
struct	cwise_promote_storage_order
struct	cwise_promote_storage_order< LhsKind, Sparse, LhsOrder, RhsOrder >
struct	cwise_promote_storage_order< Sparse, RhsKind, LhsOrder, RhsOrder >
struct	cwise_promote_storage_order< Sparse, Sparse, Order, Order >
struct	cwise_promote_storage_type
struct	cwise_promote_storage_type< A, A, Functor >
struct	cwise_promote_storage_type< A, Dense, Functor >
struct	cwise_promote_storage_type< Dense, B, Functor >
struct	cwise_promote_storage_type< Dense, Dense, Functor >
struct	cwise_promote_storage_type< Dense, Sparse, Functor >
struct	cwise_promote_storage_type< Sparse, Dense, Functor >
struct	decrement_if_fixed_size
struct	decrement_size
struct	default_digits10_impl
struct	default_digits10_impl< T, false, false >
struct	default_digits10_impl< T, false, true >
struct	default_digits_impl
struct	default_digits_impl< T, false, false >
struct	default_digits_impl< T, false, true >
struct	default_packet_traits
struct	Dense2Dense
struct	Dense2Triangular
struct	dense_assignment_loop
struct	dense_assignment_loop< Kernel, AllAtOnceTraversal, Unrolling >
struct	dense_assignment_loop< Kernel, DefaultTraversal, CompleteUnrolling >
struct	dense_assignment_loop< Kernel, DefaultTraversal, InnerUnrolling >
struct	dense_assignment_loop< Kernel, DefaultTraversal, NoUnrolling >
struct	dense_assignment_loop< Kernel, InnerVectorizedTraversal, CompleteUnrolling >
struct	dense_assignment_loop< Kernel, InnerVectorizedTraversal, InnerUnrolling >
struct	dense_assignment_loop< Kernel, InnerVectorizedTraversal, NoUnrolling >
struct	dense_assignment_loop< Kernel, LinearTraversal, CompleteUnrolling >
struct	dense_assignment_loop< Kernel, LinearTraversal, NoUnrolling >
struct	dense_assignment_loop< Kernel, LinearVectorizedTraversal, CompleteUnrolling >
struct	dense_assignment_loop< Kernel, LinearVectorizedTraversal, NoUnrolling >
struct	dense_assignment_loop< Kernel, SliceVectorizedTraversal, NoUnrolling >
class	dense_product_base
class	dense_product_base< Lhs, Rhs, Option, InnerProduct >
struct	dense_xpr_base
struct	dense_xpr_base< Derived, ArrayXpr >
struct	dense_xpr_base< Derived, MatrixXpr >
struct	determinant_impl
struct	determinant_impl< Derived, 1 >
struct	determinant_impl< Derived, 2 >
struct	determinant_impl< Derived, 3 >
struct	determinant_impl< Derived, 4 >
struct	dget
struct	dhs_cpack
struct	dhs_cpack< double, Index, DataMapper, Packet, PacketC, StorageOrder, Conjugate, PanelMode, false >
struct	dhs_cpack< double, Index, DataMapper, Packet, PacketC, StorageOrder, Conjugate, PanelMode, true >
struct	dhs_pack
struct	dhs_pack< double, Index, DataMapper, Packet2d, StorageOrder, PanelMode, false >
struct	dhs_pack< double, Index, DataMapper, Packet2d, StorageOrder, PanelMode, true >
struct	Diagonal2Dense
struct	Diagonal2Sparse
struct	diagonal_product_evaluator_base
struct	digamma_impl
struct	digamma_impl_maybe_poly
struct	digamma_impl_maybe_poly< double >
struct	digamma_impl_maybe_poly< float >
struct	digamma_retval
struct	DimensionId
struct	DimensionId< Dynamic >
struct	DimInitializer
struct	DimInitializer< Sizes<> >
struct	direct_selfadjoint_eigenvalues
struct	direct_selfadjoint_eigenvalues< SolverType, 2, false >
struct	direct_selfadjoint_eigenvalues< SolverType, 3, false >
struct	div_assign_op
struct	dot_nocheck
struct	dot_nocheck< T, U, true >
struct	DoublePacket
struct	eigen_packet_wrapper
struct	EigenBase2EigenBase
struct	eigenvalues_selector
struct	eigenvalues_selector< Derived, false >
struct	enable_if
struct	enable_if< true, T >
struct	enable_if_ref
struct	enable_if_ref< Ref< T >, Derived >
struct	EnableIf
struct	equal_op
struct	erf_impl
struct	erf_retval
struct	erfc_impl
struct	erfc_retval
struct	etor_product_coeff_impl
struct	etor_product_packet_impl
struct	etor_product_packet_impl< ColMajor, 0, Lhs, Rhs, Packet, LoadMode >
struct	etor_product_packet_impl< ColMajor, 1, Lhs, Rhs, Packet, LoadMode >
struct	etor_product_packet_impl< ColMajor, Dynamic, Lhs, Rhs, Packet, LoadMode >
struct	etor_product_packet_impl< ColMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode >
struct	etor_product_packet_impl< RowMajor, 0, Lhs, Rhs, Packet, LoadMode >
struct	etor_product_packet_impl< RowMajor, 1, Lhs, Rhs, Packet, LoadMode >
struct	etor_product_packet_impl< RowMajor, Dynamic, Lhs, Rhs, Packet, LoadMode >
struct	etor_product_packet_impl< RowMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode >
struct	eulerangles_assign_impl
struct	eulerangles_assign_impl< System, Other, 3, 1 >
struct	eulerangles_assign_impl< System, Other, 3, 3 >
struct	eval
struct	eval< Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense >
struct	eval< const Tensor< _Scalar, NumIndices_, Options, IndexType_ >, Eigen::Dense >
struct	eval< const TensorFixedSize< Scalar_, Dimensions, Options, IndexType_ >, Eigen::Dense >
struct	eval< const TensorMap< PlainObjectType, Options, MakePointer >, Eigen::Dense >
struct	eval< const TensorRef< PlainObjectType >, Eigen::Dense >
struct	eval< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense >
struct	eval< T, Dense >
struct	eval< T, DiagonalShape >
class	eval< T, IsSkyline >
struct	eval< T, Sparse >
struct	eval< Tensor< _Scalar, NumIndices_, Options, IndexType_ >, Eigen::Dense >
struct	eval< TensorAssignOp< LhsXprType, RhsXprType >, Eigen::Dense >
struct	eval< TensorBroadcastingOp< Broadcast, XprType >, Eigen::Dense >
struct	eval< TensorChippingOp< DimId, XprType >, Eigen::Dense >
struct	eval< TensorConcatenationOp< Axis, LhsXprType, RhsXprType >, Eigen::Dense >
struct	eval< TensorContractionOp< Dimensions, LhsXprType, RhsXprType, OutputKernelType >, Eigen::Dense >
struct	eval< TensorConversionOp< TargetType, XprType >, Eigen::Dense >
struct	eval< TensorConvolutionOp< Dimensions, InputXprType, KernelXprType >, Eigen::Dense >
struct	eval< TensorCustomBinaryOp< CustomBinaryFunc, LhsXprType, RhsXprType >, Eigen::Dense >
struct	eval< TensorCustomUnaryOp< CustomUnaryFunc, XprType >, Eigen::Dense >
struct	eval< TensorCwiseBinaryOp< BinaryOp, LhsXprType, RhsXprType >, Eigen::Dense >
struct	eval< TensorCwiseTernaryOp< TernaryOp, Arg1XprType, Arg2XprType, Arg3XprType >, Eigen::Dense >
struct	eval< TensorCwiseUnaryOp< UnaryOp, XprType >, Eigen::Dense >
struct	eval< TensorEvalToOp< XprType, MakePointer_ >, Eigen::Dense >
struct	eval< TensorFFTOp< FFT, XprType, FFTResultType, FFTDirection >, Eigen::Dense >
struct	eval< TensorFixedSize< Scalar_, Dimensions, Options, IndexType_ >, Eigen::Dense >
struct	eval< TensorForcedEvalOp< XprType >, Eigen::Dense >
struct	eval< TensorGeneratorOp< Generator, XprType >, Eigen::Dense >
struct	eval< TensorImagePatchOp< Rows, Cols, XprType >, Eigen::Dense >
struct	eval< TensorIndexTupleOp< XprType >, Eigen::Dense >
struct	eval< TensorInflationOp< Strides, XprType >, Eigen::Dense >
struct	eval< TensorLayoutSwapOp< XprType >, Eigen::Dense >
struct	eval< TensorMap< PlainObjectType, Options, MakePointer >, Eigen::Dense >
struct	eval< TensorPaddingOp< PaddingDimensions, XprType >, Eigen::Dense >
struct	eval< TensorPatchOp< PatchDim, XprType >, Eigen::Dense >
struct	eval< TensorReductionOp< Op, Dims, XprType, MakePointer_ >, Eigen::Dense >
struct	eval< TensorRef< PlainObjectType >, Eigen::Dense >
struct	eval< TensorReshapingOp< NewDimensions, XprType >, Eigen::Dense >
struct	eval< TensorReverseOp< ReverseDimensions, XprType >, Eigen::Dense >
struct	eval< TensorScanOp< Op, XprType >, Eigen::Dense >
struct	eval< TensorSelectOp< IfXprType, ThenXprType, ElseXprType >, Eigen::Dense >
struct	eval< TensorShufflingOp< Shuffle, XprType >, Eigen::Dense >
struct	eval< TensorSlicingOp< StartIndices, Sizes, XprType >, Eigen::Dense >
struct	eval< TensorStridingOp< Strides, XprType >, Eigen::Dense >
struct	eval< TensorStridingSlicingOp< StartIndices, StopIndices, Strides, XprType >, Eigen::Dense >
struct	eval< TensorTraceOp< Dims, XprType >, Eigen::Dense >
struct	eval< TensorTupleReducerOp< ReduceOp, Dims, XprType >, Eigen::Dense >
struct	eval< TensorVolumePatchOp< Planes, Rows, Cols, XprType >, Eigen::Dense >
class	EvalToTemp
struct	evaluator
struct	evaluator< Array< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
struct	evaluator< Block< ArgType, BlockRows, BlockCols, InnerPanel > >
struct	evaluator< const T >
struct	evaluator< CwiseBinaryOp< BinaryOp, Lhs, Rhs > >
struct	evaluator< CwiseBinaryOp< internal::scalar_product_op< Scalar1, Scalar2 >, const CwiseNullaryOp< internal::scalar_constant_op< Scalar1 >, Plain1 >, const Product< Lhs, Rhs, DefaultProduct > > >
struct	evaluator< CwiseNullaryOp< NullaryOp, PlainObjectType > >
struct	evaluator< CwiseTernaryOp< TernaryOp, Arg1, Arg2, Arg3 > >
struct	evaluator< Diagonal< ArgType, DiagIndex > >
struct	evaluator< Diagonal< const Product< Lhs, Rhs, DefaultProduct >, DiagIndex > >
struct	evaluator< DynamicSparseMatrix< _Scalar, _Options, _StorageIndex > >
struct	evaluator< EvalToTemp< ArgType > >
struct	evaluator< Map< const SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType > >
struct	evaluator< Map< PlainObjectType, MapOptions, StrideType > >
struct	evaluator< Map< SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType > >
struct	evaluator< MappedSparseMatrix< _Scalar, _Options, _StorageIndex > >
struct	evaluator< Matrix< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
struct	evaluator< NestByValue< ArgType > >
struct	evaluator< PartialReduxExpr< ArgType, MemberOp, Direction > >
struct	evaluator< PlainObjectBase< Derived > >
struct	evaluator< Product< Lhs, Rhs, Options > >
struct	evaluator< Ref< const SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType > >
struct	evaluator< Ref< const SparseVector< MatScalar, MatOptions, MatIndex >, Options, StrideType > >
struct	evaluator< Ref< PlainObjectType, RefOptions, StrideType > >
struct	evaluator< Ref< SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType > >
struct	evaluator< Ref< SparseVector< MatScalar, MatOptions, MatIndex >, Options, StrideType > >
struct	evaluator< Reshaped< ArgType, Rows, Cols, Order > >
struct	evaluator< Select< ConditionMatrixType, ThenMatrixType, ElseMatrixType > >
struct	evaluator< Solve< Decomposition, RhsType > >
struct	evaluator< SparseCompressedBase< Derived > >
struct	evaluator< SparseMatrix< _Scalar, _Options, _StorageIndex > >
struct	evaluator< SparseVector< _Scalar, _Options, _Index > >
struct	evaluator_assume_aliasing
struct	evaluator_assume_aliasing< CwiseBinaryOp< internal::scalar_difference_op< typename OtherXpr::Scalar, typename Product< Lhs, Rhs, DefaultProduct >::Scalar >, const OtherXpr, const Product< Lhs, Rhs, DefaultProduct > >, DenseShape >
struct	evaluator_assume_aliasing< CwiseBinaryOp< internal::scalar_product_op< Scalar1, Scalar2 >, const CwiseNullaryOp< internal::scalar_constant_op< Scalar1 >, Plain1 >, const Product< Lhs, Rhs, DefaultProduct > > >
struct	evaluator_assume_aliasing< CwiseBinaryOp< internal::scalar_sum_op< typename OtherXpr::Scalar, typename Product< Lhs, Rhs, DefaultProduct >::Scalar >, const OtherXpr, const Product< Lhs, Rhs, DefaultProduct > >, DenseShape >
struct	evaluator_assume_aliasing< Product< Lhs, Rhs, DefaultProduct > >
struct	evaluator_base
struct	evaluator_traits
struct	evaluator_traits< BandMatrix< _Scalar, _Rows, _Cols, _Supers, _Subs, _Options > >
struct	evaluator_traits< BandMatrixWrapper< _CoefficientsType, _Rows, _Cols, _Supers, _Subs, _Options > >
struct	evaluator_traits< Homogeneous< ArgType, Direction > >
struct	evaluator_traits< HouseholderSequence< VectorsType, CoeffsType, Side > >
struct	evaluator_traits< SelfAdjointView< MatrixType, Mode > >
struct	evaluator_traits< SparseQRMatrixQReturnType< SparseQRType > >
struct	evaluator_traits< SparseSelfAdjointView< MatrixType, Mode > >
struct	evaluator_traits< TriangularView< MatrixType, Mode > >
struct	evaluator_traits_base
struct	evaluator_wrapper_base
struct	expm1_impl
struct	expm1_impl< std::complex< RealScalar > >
struct	expm1_retval
struct	ExpressionHasTensorBroadcastingOp
struct	ExpressionHasTensorBroadcastingOp< const TensorAssignOp< LhsXprType, RhsXprType > >
struct	ExpressionHasTensorBroadcastingOp< const TensorBroadcastingOp< Broadcast, XprType > >
struct	ExpressionHasTensorBroadcastingOp< const TensorCwiseBinaryOp< BinaryOp, LhsXprType, RhsXprType > >
struct	ExpressionHasTensorBroadcastingOp< const TensorCwiseUnaryOp< UnaryOp, XprType > >
struct	extract_data_selector
struct	extract_data_selector< T, false >
struct	false_type
struct	fast_accurate_exp2
struct	fast_accurate_exp2< double >
struct	fast_accurate_exp2< float >
struct	fftw_impl
struct	fftw_plan
struct	fftw_plan< double >
struct	fftw_plan< float >
struct	fftw_plan< long double >
struct	find_best_packet
struct	find_best_packet_helper
struct	find_best_packet_helper< Size, PacketType, false >
struct	find_best_packet_helper< Size, PacketType, true >
struct	first_aligned_impl
struct	first_aligned_impl< Alignment, Derived, false >
struct	fixed_size_tensor_index_extraction_helper
struct	fixed_size_tensor_index_extraction_helper< Index, 0 >
struct	fixed_size_tensor_index_linearization_helper
struct	fixed_size_tensor_index_linearization_helper< Index, NumIndices, 0, RowMajor >
class	FixedInt
struct	FullPivHouseholderQRMatrixQReturnType
	Expression type for return value of FullPivHouseholderQR::matrixQ() More...
struct	FullReducer
struct	FullReducer< Self, Op, Eigen::SyclDevice, Vectorizable >
struct	functor_has_linear_access
struct	functor_traits
struct	functor_traits< add_assign_op< DstScalar, SrcScalar > >
struct	functor_traits< assign_op< DstScalar, SrcScalar > >
struct	functor_traits< bind1st_op< BinaryOp > >
struct	functor_traits< bind2nd_op< BinaryOp > >
struct	functor_traits< div_assign_op< DstScalar, SrcScalar > >
struct	functor_traits< GaussianGenerator< T, Index, NumDims > >
struct	functor_traits< linspaced_op< Scalar > >
struct	functor_traits< max_coeff_visitor< Scalar, NaNPropagation > >
struct	functor_traits< min_coeff_visitor< Scalar, NaNPropagation > >
struct	functor_traits< mul_assign_op< DstScalar, SrcScalar > >
struct	functor_traits< NormalRandomGenerator< Scalar > >
struct	functor_traits< numext::equal_to< T > >
struct	functor_traits< numext::not_equal_to< T > >
struct	functor_traits< scalar_abs2_op< Scalar > >
struct	functor_traits< scalar_abs_op< Scalar > >
struct	functor_traits< scalar_absolute_difference_op< LhsScalar, RhsScalar > >
struct	functor_traits< scalar_acos_op< Scalar > >
struct	functor_traits< scalar_arg_op< Scalar > >
struct	functor_traits< scalar_asin_op< Scalar > >
struct	functor_traits< scalar_atan_op< Scalar > >
struct	functor_traits< scalar_bessel_i0_op< Scalar > >
struct	functor_traits< scalar_bessel_i0e_op< Scalar > >
struct	functor_traits< scalar_bessel_i1_op< Scalar > >
struct	functor_traits< scalar_bessel_i1e_op< Scalar > >
struct	functor_traits< scalar_bessel_j0_op< Scalar > >
struct	functor_traits< scalar_bessel_j1_op< Scalar > >
struct	functor_traits< scalar_bessel_k0_op< Scalar > >
struct	functor_traits< scalar_bessel_k0e_op< Scalar > >
struct	functor_traits< scalar_bessel_k1_op< Scalar > >
struct	functor_traits< scalar_bessel_k1e_op< Scalar > >
struct	functor_traits< scalar_bessel_y0_op< Scalar > >
struct	functor_traits< scalar_bessel_y1_op< Scalar > >
struct	functor_traits< scalar_betainc_op< Scalar > >
struct	functor_traits< scalar_boolean_and_op >
struct	functor_traits< scalar_boolean_not_op< Scalar > >
struct	functor_traits< scalar_boolean_or_op >
struct	functor_traits< scalar_boolean_xor_op >
struct	functor_traits< scalar_cast_op< Eigen::bfloat16, float > >
struct	functor_traits< scalar_cast_op< Eigen::half, float > >
struct	functor_traits< scalar_cast_op< float, Eigen::bfloat16 > >
struct	functor_traits< scalar_cast_op< float, Eigen::half > >
struct	functor_traits< scalar_cast_op< int, Eigen::bfloat16 > >
struct	functor_traits< scalar_cast_op< int, Eigen::half > >
struct	functor_traits< scalar_cast_op< Scalar, NewType > >
struct	functor_traits< scalar_ceil_op< Scalar > >
struct	functor_traits< scalar_clamp_op< Scalar > >
struct	functor_traits< scalar_cmp_op< LhsScalar, RhsScalar, cmp > >
struct	functor_traits< scalar_conj_product_op< LhsScalar, RhsScalar > >
struct	functor_traits< scalar_conjugate_op< Scalar > >
struct	functor_traits< scalar_constant_op< Scalar > >
struct	functor_traits< scalar_cos_op< Scalar > >
struct	functor_traits< scalar_cosh_op< Scalar > >
struct	functor_traits< scalar_cube_op< bool > >
struct	functor_traits< scalar_cube_op< Scalar > >
struct	functor_traits< scalar_difference_op< LhsScalar, RhsScalar > >
struct	functor_traits< scalar_digamma_op< Scalar > >
struct	functor_traits< scalar_erf_op< Scalar > >
struct	functor_traits< scalar_erfc_op< Scalar > >
struct	functor_traits< scalar_exp_op< Scalar > >
struct	functor_traits< scalar_expm1_op< Scalar > >
struct	functor_traits< scalar_floor_op< Scalar > >
struct	functor_traits< scalar_fmod_op< Scalar > >
struct	functor_traits< scalar_gamma_sample_der_alpha_op< Scalar > >
struct	functor_traits< scalar_hypot_op< Scalar, Scalar > >
struct	functor_traits< scalar_identity_op< Scalar > >
struct	functor_traits< scalar_igamma_der_a_op< Scalar > >
struct	functor_traits< scalar_igamma_op< Scalar > >
struct	functor_traits< scalar_igammac_op< Scalar > >
struct	functor_traits< scalar_imag_op< Scalar > >
struct	functor_traits< scalar_imag_ref_op< Scalar > >
struct	functor_traits< scalar_inverse_op< Scalar > >
struct	functor_traits< scalar_isfinite_op< Scalar > >
struct	functor_traits< scalar_isinf_op< Scalar > >
struct	functor_traits< scalar_isnan_op< Scalar > >
struct	functor_traits< scalar_lgamma_op< Scalar > >
struct	functor_traits< scalar_log10_op< Scalar > >
struct	functor_traits< scalar_log1p_op< Scalar > >
struct	functor_traits< scalar_log2_op< Scalar > >
struct	functor_traits< scalar_log_op< Scalar > >
struct	functor_traits< scalar_logistic_op< T > >
struct	functor_traits< scalar_max_op< LhsScalar, RhsScalar, NaNPropagation > >
struct	functor_traits< scalar_min_op< LhsScalar, RhsScalar, NaNPropagation > >
struct	functor_traits< scalar_mod2_op< Scalar > >
struct	functor_traits< scalar_mod_op< Scalar > >
struct	functor_traits< scalar_ndtri_op< Scalar > >
struct	functor_traits< scalar_norm1_op >
struct	functor_traits< scalar_opposite_op< Scalar > >
struct	functor_traits< scalar_polygamma_op< Scalar > >
struct	functor_traits< scalar_pow_op< Scalar, Exponent > >
struct	functor_traits< scalar_product_op< LhsScalar, RhsScalar > >
struct	functor_traits< scalar_quotient_op< LhsScalar, RhsScalar > >
struct	functor_traits< scalar_random_op< Scalar > >
struct	functor_traits< scalar_real_op< Scalar > >
struct	functor_traits< scalar_real_ref_op< Scalar > >
struct	functor_traits< scalar_rint_op< Scalar > >
struct	functor_traits< scalar_round_op< Scalar > >
struct	functor_traits< scalar_rsqrt_op< Scalar > >
struct	functor_traits< scalar_score_coeff_op< Scalar > >
struct	functor_traits< scalar_shift_left_op< Scalar, N > >
struct	functor_traits< scalar_shift_right_op< Scalar, N > >
struct	functor_traits< scalar_sign_op< Scalar > >
struct	functor_traits< scalar_sin_op< Scalar > >
struct	functor_traits< scalar_sinh_op< Scalar > >
struct	functor_traits< scalar_sqrt_op< bool > >
struct	functor_traits< scalar_sqrt_op< Scalar > >
struct	functor_traits< scalar_square_op< bool > >
struct	functor_traits< scalar_square_op< Scalar > >
struct	functor_traits< scalar_sum_op< LhsScalar, RhsScalar > >
struct	functor_traits< scalar_tan_op< Scalar > >
struct	functor_traits< scalar_tanh_op< Scalar > >
struct	functor_traits< scalar_zeta_op< Scalar > >
struct	functor_traits< std::binary_negate< T > >
struct	functor_traits< std::binder1st< T > >
struct	functor_traits< std::binder2nd< T > >
struct	functor_traits< std::divides< T > >
struct	functor_traits< std::equal_to< T > >
struct	functor_traits< std::greater< T > >
struct	functor_traits< std::greater_equal< T > >
struct	functor_traits< std::less< T > >
struct	functor_traits< std::less_equal< T > >
struct	functor_traits< std::logical_and< T > >
struct	functor_traits< std::logical_not< T > >
struct	functor_traits< std::logical_or< T > >
struct	functor_traits< std::minus< T > >
struct	functor_traits< std::multiplies< T > >
struct	functor_traits< std::negate< T > >
struct	functor_traits< std::not_equal_to< T > >
struct	functor_traits< std::plus< T > >
struct	functor_traits< std::unary_negate< T > >
struct	functor_traits< sub_assign_op< DstScalar, SrcScalar > >
struct	functor_traits< swap_assign_op< Scalar > >
struct	functor_traits< UniformRandomGenerator< Scalar > >
struct	gamma_sample_der_alpha_impl
struct	gamma_sample_der_alpha_retval
class	GaussianGenerator
struct	gebp_kernel
struct	gebp_kernel< double, double, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >
struct	gebp_kernel< double, std::complex< double >, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >
struct	gebp_kernel< float, float, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >
struct	gebp_kernel< float, std::complex< float >, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >
struct	gebp_kernel< std::complex< double >, double, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >
struct	gebp_kernel< std::complex< double >, std::complex< double >, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >
struct	gebp_kernel< std::complex< float >, float, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >
struct	gebp_kernel< std::complex< float >, std::complex< float >, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >
class	gebp_traits
class	gebp_traits< RealScalar, std::complex< RealScalar >, false, _ConjRhs, Arch, _PacketSize >
class	gebp_traits< std::complex< RealScalar >, RealScalar, _ConjLhs, false, Arch, _PacketSize >
class	gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs, Arch, _PacketSize >
class	gemm_blocking_space
class	gemm_blocking_space< StorageOrder, _LhsScalar, _RhsScalar, MaxRows, MaxCols, MaxDepth, KcFactor, false >
class	gemm_blocking_space< StorageOrder, _LhsScalar, _RhsScalar, MaxRows, MaxCols, MaxDepth, KcFactor, true >
struct	gemm_functor
struct	gemm_pack_lhs
struct	gemm_pack_lhs< double, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode >
struct	gemm_pack_lhs< double, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode >
struct	gemm_pack_lhs< float, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode >
struct	gemm_pack_lhs< float, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode >
struct	gemm_pack_lhs< Scalar, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode >
struct	gemm_pack_lhs< Scalar, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode >
struct	gemm_pack_lhs< std::complex< double >, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode >
struct	gemm_pack_lhs< std::complex< double >, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode >
struct	gemm_pack_lhs< std::complex< float >, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode >
struct	gemm_pack_lhs< std::complex< float >, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode >
struct	gemm_pack_rhs
struct	gemm_pack_rhs< double, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode >
struct	gemm_pack_rhs< double, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode >
struct	gemm_pack_rhs< float, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode >
struct	gemm_pack_rhs< float, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode >
struct	gemm_pack_rhs< Scalar, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode >
struct	gemm_pack_rhs< Scalar, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode >
struct	gemm_pack_rhs< std::complex< double >, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode >
struct	gemm_pack_rhs< std::complex< double >, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode >
struct	gemm_pack_rhs< std::complex< float >, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode >
struct	gemm_pack_rhs< std::complex< float >, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode >
struct	GemmParallelInfo
struct	gemv_dense_selector
struct	gemv_dense_selector< OnTheLeft, StorageOrder, BlasCompatible >
struct	gemv_dense_selector< OnTheRight, ColMajor, false >
struct	gemv_dense_selector< OnTheRight, ColMajor, true >
struct	gemv_dense_selector< OnTheRight, RowMajor, false >
struct	gemv_dense_selector< OnTheRight, RowMajor, true >
struct	gemv_packet_cond
struct	gemv_packet_cond< GEMVPacketFull, T1, T2, T3 >
struct	gemv_packet_cond< GEMVPacketHalf, T1, T2, T3 >
struct	gemv_static_vector_if
struct	gemv_static_vector_if< Scalar, Size, Dynamic, true >
struct	gemv_static_vector_if< Scalar, Size, MaxSize, false >
struct	gemv_static_vector_if< Scalar, Size, MaxSize, true >
class	gemv_traits
struct	gen_numeric_list
struct	gen_numeric_list< T, 0, start, ii... >
struct	gen_numeric_list_repeated
struct	gen_numeric_list_repeated< T, 0, V, nn... >
struct	gen_numeric_list_reversed
struct	gen_numeric_list_reversed< T, 0, start, ii... >
struct	gen_numeric_list_swapped_pair
struct	gen_numeric_list_swapped_pair< T, 0, a, b, start, ii... >
struct	general_matrix_matrix_product
struct	general_matrix_matrix_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, ColMajor, ResInnerStride >
struct	general_matrix_matrix_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, RowMajor, ResInnerStride >
struct	general_matrix_matrix_rankupdate
struct	general_matrix_matrix_triangular_product
struct	general_matrix_matrix_triangular_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, ColMajor, ResInnerStride, UpLo, Version >
struct	general_matrix_matrix_triangular_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, RowMajor, ResInnerStride, UpLo, Version >
struct	general_matrix_vector_product
struct	general_matrix_vector_product< Index, LhsScalar, LhsMapper, ColMajor, ConjugateLhs, RhsScalar, RhsMapper, ConjugateRhs, Version >
struct	general_matrix_vector_product< Index, LhsScalar, LhsMapper, RowMajor, ConjugateLhs, RhsScalar, RhsMapper, ConjugateRhs, Version >
struct	general_matrix_vector_product_gemv
class	generic_dense_assignment_kernel
class	generic_dense_assignment_kernel< DstEvaluatorTypeT, SrcEvaluatorTypeT, swap_assign_op< typename DstEvaluatorTypeT::Scalar >, Specialized >
struct	generic_i0
struct	generic_i0e
struct	generic_i0e< T, double >
struct	generic_i0e< T, float >
struct	generic_i1
struct	generic_i1e
struct	generic_i1e< T, double >
struct	generic_i1e< T, float >
struct	generic_j0
struct	generic_j0< T, double >
struct	generic_j0< T, float >
struct	generic_j1
struct	generic_j1< T, double >
struct	generic_j1< T, float >
struct	generic_k0
struct	generic_k0< T, double >
struct	generic_k0< T, float >
struct	generic_k0e
struct	generic_k0e< T, double >
struct	generic_k0e< T, float >
struct	generic_k1
struct	generic_k1< T, double >
struct	generic_k1< T, float >
struct	generic_k1e
struct	generic_k1e< T, double >
struct	generic_k1e< T, float >
class	generic_matrix_wrapper
class	generic_matrix_wrapper< MatrixType, false >
class	generic_matrix_wrapper< MatrixType, true >
struct	generic_product_impl
struct	generic_product_impl< Homogeneous< LhsArg, Horizontal >, Rhs, HomogeneousShape, DenseShape, ProductTag >
struct	generic_product_impl< Inverse< Lhs >, Rhs, PermutationShape, MatrixShape, ProductTag >
struct	generic_product_impl< Lhs, Homogeneous< RhsArg, Vertical >, DenseShape, HomogeneousShape, ProductTag >
struct	generic_product_impl< Lhs, Homogeneous< RhsArg, Vertical >, TriangularShape, HomogeneousShape, ProductTag >
struct	generic_product_impl< Lhs, Inverse< Rhs >, MatrixShape, PermutationShape, ProductTag >
struct	generic_product_impl< Lhs, Rhs, DenseShape, DenseShape, CoeffBasedProductMode >
struct	generic_product_impl< Lhs, Rhs, DenseShape, DenseShape, GemvProduct >
struct	generic_product_impl< Lhs, Rhs, DenseShape, DenseShape, InnerProduct >
struct	generic_product_impl< Lhs, Rhs, DenseShape, DenseShape, LazyCoeffBasedProductMode >
struct	generic_product_impl< Lhs, Rhs, DenseShape, DenseShape, OuterProduct >
struct	generic_product_impl< Lhs, Rhs, DenseShape, SelfAdjointShape, ProductTag >
struct	generic_product_impl< Lhs, Rhs, DenseShape, SparseShape, ProductType >
struct	generic_product_impl< Lhs, Rhs, DenseShape, SparseTriangularShape, ProductType >
struct	generic_product_impl< Lhs, Rhs, DenseShape, TriangularShape, ProductTag >
struct	generic_product_impl< Lhs, Rhs, MatrixShape, PermutationShape, ProductTag >
struct	generic_product_impl< Lhs, Rhs, MatrixShape, TranspositionsShape, ProductTag >
struct	generic_product_impl< Lhs, Rhs, PermutationShape, MatrixShape, ProductTag >
struct	generic_product_impl< Lhs, Rhs, SelfAdjointShape, DenseShape, ProductTag >
struct	generic_product_impl< Lhs, Rhs, SparseShape, DenseShape, ProductType >
struct	generic_product_impl< Lhs, Rhs, SparseShape, SparseShape, ProductType >
struct	generic_product_impl< Lhs, Rhs, SparseShape, SparseTriangularShape, ProductType >
struct	generic_product_impl< Lhs, Rhs, SparseTriangularShape, DenseShape, ProductType >
struct	generic_product_impl< Lhs, Rhs, SparseTriangularShape, SparseShape, ProductType >
struct	generic_product_impl< Lhs, Rhs, TranspositionsShape, MatrixShape, ProductTag >
struct	generic_product_impl< Lhs, Rhs, TriangularShape, DenseShape, ProductTag >
struct	generic_product_impl< Lhs, RhsView, DenseShape, SparseSelfAdjointShape, ProductType >
struct	generic_product_impl< Lhs, Transpose< Rhs >, MatrixShape, TranspositionsShape, ProductTag >
struct	generic_product_impl< LhsView, Rhs, SparseSelfAdjointShape, DenseShape, ProductType >
struct	generic_product_impl< MatrixReplacement, Rhs, SparseShape, DenseShape, GemvProduct >
struct	generic_product_impl< Transform< Scalar, Dim, Mode, Options >, Homogeneous< RhsArg, Vertical >, DenseShape, HomogeneousShape, ProductTag >
struct	generic_product_impl< Transpose< Lhs >, Rhs, TranspositionsShape, MatrixShape, ProductTag >
struct	generic_product_impl_base
class	generic_randaccess_stl_iterator
struct	generic_xpr_base
struct	generic_xpr_base< Derived, MatrixXpr, SolverStorage >
struct	generic_xpr_base< Derived, MatrixXpr, Sparse >
struct	generic_xpr_base< Derived, XprKind, Dense >
struct	generic_y0
struct	generic_y0< T, double >
struct	generic_y0< T, float >
struct	generic_y1
struct	generic_y1< T, double >
struct	generic_y1< T, float >
struct	GenericDimReducer
struct	GenericDimReducer< 0, Self, Op >
struct	GenericDimReducer<-1, Self, Op >
struct	GenericReducer< Self, Op, Eigen::SyclDevice >
struct	get
struct	get< 0, numeric_list< T, a, as... > >
struct	get< 0, type_list< a, as... > >
struct	get< n, numeric_list< T, a, as... > >
struct	get< n, type_list< a, as... > >
struct	get_boxes_helper
struct	get_boxes_helper< ObjectList, VolumeList, int >
struct	get_compile_time_incr
struct	get_compile_time_incr< AllRange< Size > >
struct	get_compile_time_incr< ArithmeticSequence< FirstType, SizeType, IncrType > >
struct	get_compile_time_incr< SingleRange >
struct	get_compiletime_reshape_order
struct	get_compiletime_reshape_size
struct	get_compiletime_reshape_size< AutoSize_t, OtherSize, TotalSize >
struct	get_factor
struct	get_factor< Scalar, typename NumTraits< Scalar >::Real >
struct	get_fixed_value
struct	get_fixed_value< FixedInt< N >(*)(), Default >
struct	get_fixed_value< FixedInt< N >, Default >
struct	get_fixed_value< variable_if_dynamic< T, N >, Default >
struct	get_fixed_value< VariableAndFixedInt< N >, Default >
struct	global_math_functions_filtering_base
struct	global_math_functions_filtering_base< T, typename always_void< typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl >::type >
struct	glue_shapes
struct	glue_shapes< DenseShape, TriangularShape >
struct	glue_shapes< SparseShape, SelfAdjointShape >
struct	glue_shapes< SparseShape, TriangularShape >
struct	greater_equal_op
struct	greater_equal_zero_op
struct	greater_op
struct	h_apply_op
struct	h_apply_op_helper
struct	h_apply_op_helper< true, op, additional_param, values... >
struct	h_array_reduce
struct	h_array_reduce< Reducer, T, 0 >
struct	h_array_reduce< Reducer, T, N, 0 >
struct	h_instantiate_by_c_array
struct	h_instantiate_by_c_array< InstType, ArrType, 0, false, Ps... >
struct	h_instantiate_by_c_array< InstType, ArrType, 0, true, Ps... >
struct	h_instantiate_by_c_array< InstType, ArrType, N, false, Ps... >
struct	h_instantiate_by_c_array< InstType, ArrType, N, true, Ps... >
struct	h_repeat
struct	h_skip
struct	h_skip_helper_numeric
struct	h_skip_helper_numeric< T, 0 >
struct	h_skip_helper_numeric< T, 0, i, ii... >
struct	h_skip_helper_numeric< T, n >
struct	h_skip_helper_numeric< T, n, i, ii... >
struct	h_skip_helper_type
struct	h_skip_helper_type< 0 >
struct	h_skip_helper_type< 0, t, tt... >
struct	h_skip_helper_type< n >
struct	h_skip_helper_type< n, t, tt... >
struct	has_binary_operator
struct	has_binary_operator< linspaced_op< Scalar >, IndexType >
struct	has_binary_operator< scalar_constant_op< Scalar >, IndexType >
struct	has_binary_operator< scalar_identity_op< Scalar >, IndexType >
struct	has_binary_operator< scalar_random_op< Scalar >, IndexType >
struct	has_direct_access
struct	has_none
struct	has_nullary_operator
struct	has_nullary_operator< linspaced_op< Scalar >, IndexType >
struct	has_nullary_operator< scalar_constant_op< Scalar >, IndexType >
struct	has_nullary_operator< scalar_identity_op< Scalar >, IndexType >
struct	has_nullary_operator< scalar_random_op< Scalar >, IndexType >
struct	has_ReturnType
struct	has_std_result_type
struct	has_tr1_result
struct	has_unary_operator
struct	has_unary_operator< linspaced_op< Scalar >, IndexType >
struct	has_unary_operator< scalar_constant_op< Scalar >, IndexType >
struct	has_unary_operator< scalar_identity_op< Scalar >, IndexType >
struct	has_unary_operator< scalar_random_op< Scalar >, IndexType >
struct	HessenbergDecompositionMatrixHReturnType
	Expression type for return value of HessenbergDecomposition::matrixH() More...
struct	homogeneous_left_product_impl
struct	homogeneous_left_product_impl< Homogeneous< MatrixType, Vertical >, Lhs >
struct	homogeneous_left_product_refactoring_helper
struct	homogeneous_right_product_impl
struct	homogeneous_right_product_impl< Homogeneous< MatrixType, Horizontal >, Rhs >
struct	homogeneous_right_product_refactoring_helper
struct	householder_qr_inplace_blocked
struct	HouseholderSequenceShape
struct	hseq_side_dependent_impl
struct	hseq_side_dependent_impl< VectorsType, CoeffsType, OnTheRight >
struct	hypot_impl
struct	hypot_retval
struct	id_numeric
struct	id_type
struct	igamma_der_a_impl
struct	igamma_der_a_retval
struct	igamma_generic_impl
struct	igamma_impl
struct	igamma_retval
struct	igamma_series_impl
struct	igammac_cf_impl
struct	igammac_impl
struct	igammac_retval
struct	imag_default_impl
struct	imag_default_impl< Scalar, true >
struct	imag_impl
struct	imag_ref_default_impl
struct	imag_ref_default_impl< Scalar, false >
struct	imag_ref_impl
struct	imag_ref_retval
struct	imag_retval
struct	image_retval
struct	image_retval< FullPivLU< _MatrixType > >
class	image_retval_base
struct	ImagePatchCopyOp
struct	ImagePatchCopyOp< Self, true >
struct	ImagePatchPaddingOp
struct	increment_if_fixed_size
struct	index_known_statically_impl
struct	index_known_statically_impl< const DimensionList< Index, Rank > >
struct	index_known_statically_impl< DimensionList< Index, Rank > >
struct	index_pair_first_statically_eq_impl
struct	index_pair_second_statically_eq_impl
struct	index_statically_eq_impl
struct	index_statically_eq_impl< const DimensionList< Index, Rank > >
struct	index_statically_eq_impl< DimensionList< Index, Rank > >
struct	index_statically_gt_impl
struct	index_statically_gt_impl< const DimensionList< Index, Rank > >
struct	index_statically_gt_impl< DimensionList< Index, Rank > >
struct	index_statically_lt_impl
struct	index_statically_lt_impl< const DimensionList< Index, Rank > >
struct	index_statically_lt_impl< DimensionList< Index, Rank > >
struct	index_statically_ne_impl
struct	index_statically_ne_impl< const DimensionList< Index, Rank > >
struct	index_statically_ne_impl< DimensionList< Index, Rank > >
struct	IndexBased
class	indexed_based_stl_iterator_base
struct	indexed_based_stl_iterator_traits
struct	indexed_based_stl_iterator_traits< generic_randaccess_stl_iterator< _XprType > >
struct	indexed_based_stl_iterator_traits< subvector_stl_iterator< _XprType, Direction > >
struct	indexed_based_stl_iterator_traits< subvector_stl_reverse_iterator< _XprType, Direction > >
class	indexed_based_stl_reverse_iterator_base
struct	IndexedViewCompatibleType
struct	IndexedViewCompatibleType< all_t, XprSize >
struct	IndexedViewCompatibleType< ArithmeticSequence< FirstType, SizeType, IncrType >, XprSize >
struct	IndexedViewCompatibleType< T, XprSize, typename enable_if< symbolic::is_symbolic< T >::value >::type >
struct	IndexedViewCompatibleType< T, XprSize, typename internal::enable_if< internal::is_integral< T >::value >::type >
class	IndexMapper
struct	indices_statically_known_to_increase_impl
struct	indices_statically_known_to_increase_impl< const DimensionList< Index, Rank > >
struct	indices_statically_known_to_increase_impl< DimensionList< Index, Rank > >
class	inner_iterator_selector
struct	inner_stride_at_compile_time
struct	inner_stride_at_compile_time< Derived, false >
struct	InnerMostDimPreserver
struct	InnerMostDimPreserver< 0, Self, Op, true >
struct	InnerMostDimPreserver< DimIndex, Self, Op, true >
struct	InnerMostDimPreserver<-1, Self, Op, true >
struct	InnerMostDimReducer
struct	InnerMostDimReducer< Self, Op, false, true >
struct	InnerMostDimReducer< Self, Op, true, false >
struct	InnerMostDimReducer< Self, Op, true, true >
struct	InnerReducer
struct	InnerReducer< Self, Op, Eigen::SyclDevice >
struct	inplace_transpose_selector
struct	inplace_transpose_selector< MatrixType, false, MatchPacketSize >
struct	inplace_transpose_selector< MatrixType, true, false >
struct	inplace_transpose_selector< MatrixType, true, true >
struct	intersector_helper1
struct	intersector_helper2
struct	inverse_impl
struct	invoke_result
struct	invoke_result< F, ArgType0, ArgType1, void >
struct	invoke_result< F, ArgType0, void, void >
struct	invoke_result< F, void, void, void >
struct	is_arithmetic
struct	is_arithmetic< __m128 >
struct	is_arithmetic< __m128d >
struct	is_arithmetic< __m128i >
struct	is_arithmetic< __m256 >
struct	is_arithmetic< __m256d >
struct	is_arithmetic< __m256i >
struct	is_arithmetic< __m512 >
struct	is_arithmetic< __m512d >
struct	is_arithmetic< __m512i >
struct	is_arithmetic< bfloat16 >
struct	is_arithmetic< bool >
struct	is_arithmetic< char >
struct	is_arithmetic< double >
struct	is_arithmetic< float >
struct	is_arithmetic< half >
struct	is_arithmetic< long double >
struct	is_arithmetic< Packet16b >
struct	is_arithmetic< Packet16bf >
struct	is_arithmetic< Packet16h >
struct	is_arithmetic< Packet4bf >
struct	is_arithmetic< Packet4i >
struct	is_arithmetic< Packet8bf >
struct	is_arithmetic< Packet8h >
struct	is_arithmetic< signed char >
struct	is_arithmetic< signed int >
struct	is_arithmetic< signed long >
struct	is_arithmetic< signed short >
struct	is_arithmetic< unsigned char >
struct	is_arithmetic< unsigned int >
struct	is_arithmetic< unsigned long >
struct	is_arithmetic< unsigned short >
struct	is_const
struct	is_const< T const >
struct	is_convertible
struct	is_convertible< const T, const T & >
struct	is_convertible< T, T & >
struct	is_convertible_impl
struct	is_diagonal
struct	is_diagonal< DiagonalBase< T > >
struct	is_diagonal< DiagonalMatrix< T, S > >
struct	is_diagonal< DiagonalWrapper< T > >
struct	is_exp_known_type
struct	is_exp_known_type< double >
struct	is_exp_known_type< float >
struct	is_exp_known_type< long double >
struct	is_identity
struct	is_identity< CwiseNullaryOp< internal::scalar_identity_op< typename T::Scalar >, T > >
struct	is_input_scalar
struct	is_input_scalar< Sizes< Indices... > >
struct	is_input_scalar< Sizes<> >
struct	is_integral
struct	is_integral< bool >
struct	is_integral< char >
struct	is_integral< signed char >
struct	is_integral< signed int >
struct	is_integral< signed long >
struct	is_integral< signed short >
struct	is_integral< unsigned char >
struct	is_integral< unsigned int >
struct	is_integral< unsigned long >
struct	is_integral< unsigned short >
struct	is_lvalue
struct	is_ref_compatible
struct	is_ref_compatible_impl
struct	is_same
struct	is_same< T, T >
struct	is_same_gf
struct	is_scalar
struct	is_valid_index_type
struct	is_void
struct	isApprox_selector
struct	isApprox_selector< Derived, OtherDerived, true >
struct	isMuchSmallerThan_object_selector
struct	isMuchSmallerThan_object_selector< Derived, OtherDerived, true >
struct	isMuchSmallerThan_scalar_selector
struct	isMuchSmallerThan_scalar_selector< Derived, true >
struct	IsTileable
struct	IsValidAxis
struct	IsVectorizable
struct	IsVectorizable< GpuDevice, Expression >
struct	IteratorBased
struct	kernel_retval
struct	kernel_retval< FullPivLU< _MatrixType > >
class	kernel_retval_base
struct	kiss_cpx_fft
struct	kissfft_impl
struct	lapacke_llt
struct	last_row_process_16_packets
struct	last_row_process_16_packets< LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs, 16 >
struct	ldlt_inplace
struct	ldlt_inplace< Lower >
struct	ldlt_inplace< Upper >
struct	LDLT_Traits
struct	LDLT_Traits< MatrixType, Lower >
struct	LDLT_Traits< MatrixType, Upper >
struct	lesser_equal_op
struct	lesser_op
class	level3_blocking
struct	lgamma_impl
struct	lgamma_retval
struct	lhs_process_fraction_of_packet
struct	lhs_process_one_packet
struct	linspaced_op
struct	linspaced_op_impl
struct	linspaced_op_impl< Scalar, false >
struct	linspaced_op_impl< Scalar, true >
struct	llt_inplace
struct	llt_inplace< Scalar, Lower >
struct	llt_inplace< Scalar, Upper >
struct	LLT_Traits
struct	LLT_Traits< MatrixType, Lower >
struct	LLT_Traits< MatrixType, Upper >
struct	log1p_impl
struct	log1p_impl< std::complex< RealScalar > >
struct	log1p_retval
struct	log_impl
struct	log_impl< std::complex< Scalar > >
struct	logical_and_op
struct	logical_or_op
struct	LowerBoundIndex
struct	lpNorm_selector
struct	lpNorm_selector< Derived, 1 >
struct	lpNorm_selector< Derived, 2 >
struct	lpNorm_selector< Derived, Infinity >
struct	LU_GlobalLU_t
struct	LU_kernel_bmod
struct	LU_kernel_bmod< 1 >
struct	make_coherent_impl
struct	make_coherent_impl< A, Matrix< B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols > >
struct	make_coherent_impl< Matrix< A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols >, B >
struct	make_coherent_impl< Matrix< A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols >, Matrix< B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols > >
struct	make_integer
struct	make_integer< bfloat16 >
struct	make_integer< double >
struct	make_integer< float >
struct	make_integer< half >
class	make_proper_matrix_type
struct	make_size_type
struct	make_unsigned
struct	make_unsigned< char >
struct	make_unsigned< signed char >
struct	make_unsigned< signed int >
struct	make_unsigned< signed long >
struct	make_unsigned< signed short >
struct	make_unsigned< unsigned char >
struct	make_unsigned< unsigned int >
struct	make_unsigned< unsigned long >
struct	make_unsigned< unsigned short >
struct	mapbase_evaluator
class	MappedSuperNodalMatrix
	a class to manipulate the L supernodal factor from the SparseLU factorization More...
struct	matrix_exp_computeUV
	Compute the (17,17)-Padé approximant to the exponential. More...
struct	matrix_exp_computeUV< MatrixType, double >
struct	matrix_exp_computeUV< MatrixType, float >
struct	matrix_exp_computeUV< MatrixType, long double >
struct	matrix_function_compute
	Class for computing matrix functions. More...
struct	matrix_function_compute< MatrixType, 0 >
struct	matrix_function_compute< MatrixType, 1 >
struct	matrix_log_max_pade_degree
struct	matrix_log_min_pade_degree
struct	matrix_sqrt_compute
	Helper struct for computing matrix square roots of general matrices. More...
struct	matrix_sqrt_compute< MatrixType, 0 >
struct	matrix_sqrt_compute< MatrixType, 1 >
struct	matrix_swap_impl
struct	matrix_swap_impl< MatrixTypeA, MatrixTypeB, true >
struct	matrix_type_times_scalar_type
struct	MatrixExponentialScalingOp
	Scaling operator. More...
class	MatrixFunctionAtomic
	Helper class for computing matrix functions of atomic matrices. More...
class	MatrixLogarithmAtomic
	Helper class for computing matrix logarithm of atomic matrices. More...
struct	max_coeff_visitor
struct	max_coeff_visitor< Derived, PropagateNaN >
struct	max_coeff_visitor< Derived, PropagateNumbers >
struct	MaxReducer
struct	mconcat
struct	mconcat< a >
struct	mconcat< a, b >
struct	mconcat< a, b, cs... >
struct	MeanReducer
struct	member_lpnorm
struct	member_redux
struct	meta_floor_log2
struct	meta_floor_log2< n, lower, upper, meta_floor_log2_bogus >
struct	meta_floor_log2< n, lower, upper, meta_floor_log2_move_down >
struct	meta_floor_log2< n, lower, upper, meta_floor_log2_move_up >
struct	meta_floor_log2< n, lower, upper, meta_floor_log2_terminate >
struct	meta_floor_log2_selector
struct	meta_least_common_multiple
struct	meta_least_common_multiple< A, B, K, Done, false >
struct	meta_least_common_multiple< A, B, K, true, true >
struct	meta_no
class	meta_sqrt
class	meta_sqrt< Y, InfX, SupX, true >
struct	meta_yes
struct	min_coeff_visitor
struct	min_coeff_visitor< Derived, PropagateNaN >
struct	min_coeff_visitor< Derived, PropagateNumbers >
struct	MinMaxBottomValue
struct	MinMaxBottomValue< T, false, false >
struct	MinMaxBottomValue< T, false, true >
struct	MinMaxBottomValue< T, true, false >
struct	MinReducer
struct	mul_assign_op
struct	ndtri_impl
struct	ndtri_retval
struct	negation_op
struct	nested
struct	nested< const Tensor< Scalar_, NumIndices_, Options_, IndexType_ > >
struct	nested< const TensorFixedSize< Scalar_, Dimensions, Options, IndexType_ > >
struct	nested< const TensorRef< PlainObjectType > >
struct	nested< Tensor< Scalar_, NumIndices_, Options_, IndexType_ > >
struct	nested< TensorAssignOp< LhsXprType, RhsXprType >, 1, typename eval< TensorAssignOp< LhsXprType, RhsXprType > >::type >
struct	nested< TensorBroadcastingOp< Broadcast, XprType >, 1, typename eval< TensorBroadcastingOp< Broadcast, XprType > >::type >
struct	nested< TensorChippingOp< DimId, XprType >, 1, typename eval< TensorChippingOp< DimId, XprType > >::type >
struct	nested< TensorConcatenationOp< Axis, LhsXprType, RhsXprType >, 1, typename eval< TensorConcatenationOp< Axis, LhsXprType, RhsXprType > >::type >
struct	nested< TensorContractionOp< Dimensions, LhsXprType, RhsXprType, OutputKernelType >, 1, typename eval< TensorContractionOp< Dimensions, LhsXprType, RhsXprType, OutputKernelType > >::type >
struct	nested< TensorConversionOp< TargetType, XprType >, 1, typename eval< TensorConversionOp< TargetType, XprType > >::type >
struct	nested< TensorConvolutionOp< Dimensions, InputXprType, KernelXprType >, 1, typename eval< TensorConvolutionOp< Dimensions, InputXprType, KernelXprType > >::type >
struct	nested< TensorCustomBinaryOp< CustomBinaryFunc, LhsXprType, RhsXprType > >
struct	nested< TensorCustomUnaryOp< CustomUnaryFunc, XprType > >
struct	nested< TensorCwiseBinaryOp< BinaryOp, LhsXprType, RhsXprType >, 1, typename eval< TensorCwiseBinaryOp< BinaryOp, LhsXprType, RhsXprType > >::type >
struct	nested< TensorCwiseTernaryOp< TernaryOp, Arg1XprType, Arg2XprType, Arg3XprType >, 1, typename eval< TensorCwiseTernaryOp< TernaryOp, Arg1XprType, Arg2XprType, Arg3XprType > >::type >
struct	nested< TensorCwiseUnaryOp< UnaryOp, XprType >, 1, typename eval< TensorCwiseUnaryOp< UnaryOp, XprType > >::type >
struct	nested< TensorEvalToOp< XprType, MakePointer_ >, 1, typename eval< TensorEvalToOp< XprType, MakePointer_ > >::type >
struct	nested< TensorFFTOp< FFT, XprType, FFTResultType, FFTDirection >, 1, typename eval< TensorFFTOp< FFT, XprType, FFTResultType, FFTDirection > >::type >
struct	nested< TensorFixedSize< Scalar_, Dimensions, Options, IndexType_ > >
struct	nested< TensorForcedEvalOp< XprType >, 1, typename eval< TensorForcedEvalOp< XprType > >::type >
struct	nested< TensorGeneratorOp< Generator, XprType >, 1, typename eval< TensorGeneratorOp< Generator, XprType > >::type >
struct	nested< TensorImagePatchOp< Rows, Cols, XprType >, 1, typename eval< TensorImagePatchOp< Rows, Cols, XprType > >::type >
struct	nested< TensorIndexTupleOp< XprType >, 1, typename eval< TensorIndexTupleOp< XprType > >::type >
struct	nested< TensorInflationOp< Strides, XprType >, 1, typename eval< TensorInflationOp< Strides, XprType > >::type >
struct	nested< TensorLayoutSwapOp< XprType >, 1, typename eval< TensorLayoutSwapOp< XprType > >::type >
struct	nested< TensorPaddingOp< PaddingDimensions, XprType >, 1, typename eval< TensorPaddingOp< PaddingDimensions, XprType > >::type >
struct	nested< TensorPatchOp< PatchDim, XprType >, 1, typename eval< TensorPatchOp< PatchDim, XprType > >::type >
struct	nested< TensorReductionOp< Op, Dims, XprType, MakePointer_ >, 1, typename eval< TensorReductionOp< Op, Dims, XprType, MakePointer_ > >::type >
struct	nested< TensorRef< PlainObjectType > >
struct	nested< TensorReshapingOp< NewDimensions, XprType >, 1, typename eval< TensorReshapingOp< NewDimensions, XprType > >::type >
struct	nested< TensorReverseOp< ReverseDimensions, XprType >, 1, typename eval< TensorReverseOp< ReverseDimensions, XprType > >::type >
struct	nested< TensorScanOp< Op, XprType >, 1, typename eval< TensorScanOp< Op, XprType > >::type >
struct	nested< TensorSelectOp< IfXprType, ThenXprType, ElseXprType >, 1, typename eval< TensorSelectOp< IfXprType, ThenXprType, ElseXprType > >::type >
struct	nested< TensorShufflingOp< Shuffle, XprType >, 1, typename eval< TensorShufflingOp< Shuffle, XprType > >::type >
struct	nested< TensorSlicingOp< StartIndices, Sizes, XprType >, 1, typename eval< TensorSlicingOp< StartIndices, Sizes, XprType > >::type >
struct	nested< TensorStridingOp< Strides, XprType >, 1, typename eval< TensorStridingOp< Strides, XprType > >::type >
struct	nested< TensorStridingSlicingOp< StartIndices, StopIndices, Strides, XprType >, 1, typename eval< TensorStridingSlicingOp< StartIndices, StopIndices, Strides, XprType > >::type >
struct	nested< TensorTraceOp< Dims, XprType >, 1, typename eval< TensorTraceOp< Dims, XprType > >::type >
struct	nested< TensorTupleReducerOp< ReduceOp, Dims, XprType >, 1, typename eval< TensorTupleReducerOp< ReduceOp, Dims, XprType > >::type >
struct	nested< TensorVolumePatchOp< Planes, Rows, Cols, XprType >, 1, typename eval< TensorVolumePatchOp< Planes, Rows, Cols, XprType > >::type >
struct	nested_eval
struct	nested_eval< ReturnByValue< Derived >, n, PlainObject >
class	no_assignment_operator
struct	non_integral_type_placement_new
struct	non_integral_type_placement_new< Eigen::SyclDevice, CoeffReturnType >
class	noncopyable
struct	norm1_default_impl
struct	norm1_default_impl< Scalar, false >
struct	norm1_default_impl< Scalar, true >
struct	norm1_impl
struct	norm1_retval
class	NormalRandomGenerator
struct	not_equal_op
struct	not_op
struct	nullary_result_of_select
struct	nullary_result_of_select< Func, sizeof(has_std_result_type)>
struct	nullary_result_of_select< Func, sizeof(has_tr1_result)>
struct	nullary_wrapper
struct	nullary_wrapper< Scalar, NullaryOp, false, false, false >
struct	nullary_wrapper< Scalar, NullaryOp, false, false, true >
struct	nullary_wrapper< Scalar, NullaryOp, false, true, false >
struct	nullary_wrapper< Scalar, NullaryOp, true, false, false >
struct	numeric_list
struct	numeric_list< T, n, nn... >
struct	OP
struct	OP< MatrixSolver, MatrixType, Scalar, false >
struct	OP< MatrixSolver, MatrixType, Scalar, true >
struct	operator_bitwise_helper
struct	OrReducer
struct	outer_stride_at_compile_time
struct	outer_stride_at_compile_time< Derived, false >
struct	OuterReducer
struct	OuterReducer< Self, Op, Eigen::SyclDevice >
union	Packet
struct	Packet1cd
struct	Packet1cf
struct	Packet2cd
struct	Packet2cf
struct	Packet4cd
struct	Packet4cf
struct	Packet8cf
struct	packet_conditional
struct	packet_conditional< GEBPPacketFull, T1, T2, T3 >
struct	packet_conditional< GEBPPacketHalf, T1, T2, T3 >
struct	packet_traits
struct	packet_traits< bfloat16 >
struct	packet_traits< bool >
struct	packet_traits< const T >
struct	packet_traits< double >
struct	packet_traits< Eigen::half >
struct	packet_traits< float >
struct	packet_traits< half >
struct	packet_traits< int >
struct	packet_traits< int16_t >
struct	packet_traits< int32_t >
struct	packet_traits< int64_t >
struct	packet_traits< int8_t >
struct	packet_traits< numext::int32_t >
struct	packet_traits< short int >
struct	packet_traits< signed char >
struct	packet_traits< std::complex< double > >
struct	packet_traits< std::complex< float > >
struct	packet_traits< uint16_t >
struct	packet_traits< uint32_t >
struct	packet_traits< uint64_t >
struct	packet_traits< uint8_t >
struct	packet_traits< unsigned char >
struct	packet_traits< unsigned short int >
struct	PacketBlock
struct	PacketBlockManagement
struct	PacketBlockManagement< Index, Scalar, Packet, n, -1, RowMajor >
struct	PacketBlockManagement< Index, Scalar, Packet, n, -1, StorageOrder >
struct	PacketBlockManagement< Index, Scalar, Packet, n, idx, RowMajor >
struct	PacketConv
struct	PacketConv< SrcPacket, TargetPacket, LoadMode, false, true >
struct	PacketConv< SrcPacket, TargetPacket, LoadMode, true, IsSameT >
struct	PacketConv< SrcPacket, TargetPacket, LoadMode, true, true >
struct	packetwise_redux_impl
struct	packetwise_redux_impl< Func, Evaluator, CompleteUnrolling >
struct	packetwise_redux_impl< Func, Evaluator, NoUnrolling >
struct	packetwise_redux_traits
struct	panel_dfs_traits
struct	pardiso_run_selector
struct	pardiso_run_selector< long long int >
struct	pardiso_traits
struct	pardiso_traits< PardisoLDLT< _MatrixType, Options > >
struct	pardiso_traits< PardisoLLT< _MatrixType, Options > >
struct	pardiso_traits< PardisoLU< _MatrixType > >
struct	partial_lu_impl
struct	pastix_traits
struct	pastix_traits< PastixLDLT< _MatrixType, Options > >
struct	pastix_traits< PastixLLT< _MatrixType, Options > >
struct	pastix_traits< PastixLU< _MatrixType > >
struct	pchebevl
struct	perfvalues
struct	permutation_matrix_product
struct	permutation_matrix_product< ExpressionType, Side, Transposed, DenseShape >
struct	permutation_matrix_product< ExpressionType, Side, Transposed, HomogeneousShape >
struct	permutation_matrix_product< ExpressionType, Side, Transposed, SparseShape >
struct	plain_array
struct	plain_array< T, 0, MatrixOrArrayOptions, Alignment >
struct	plain_array< T, Size, MatrixOrArrayOptions, 16 >
struct	plain_array< T, Size, MatrixOrArrayOptions, 32 >
struct	plain_array< T, Size, MatrixOrArrayOptions, 64 >
struct	plain_array< T, Size, MatrixOrArrayOptions, 8 >
struct	plain_array_helper
struct	plain_col_type
struct	plain_constant_type
struct	plain_diag_type
struct	plain_matrix_type
struct	plain_matrix_type< T, Dense >
struct	plain_matrix_type< T, DiagonalShape >
struct	plain_matrix_type< T, Sparse >
struct	plain_matrix_type_column_major
struct	plain_matrix_type_dense
struct	plain_matrix_type_dense< T, ArrayXpr, Flags >
struct	plain_matrix_type_dense< T, MatrixXpr, Flags >
struct	plain_matrix_type_row_major
struct	plain_object_eval
struct	plain_object_eval< T, Dense >
struct	plain_object_eval< T, Sparse >
struct	plain_row_type
class	plainobjectbase_evaluator_data
class	plainobjectbase_evaluator_data< Scalar, Dynamic >
struct	pldexp_fast_impl
struct	pminmax_impl
struct	pminmax_impl< PropagateNaN >
struct	pminmax_impl< PropagateNumbers >
class	pointer_based_stl_iterator
struct	Pointer_type_promotion
struct	Pointer_type_promotion< A, A >
struct	polygamma_impl
struct	polygamma_retval
struct	possibly_same_dense
struct	pow_impl
struct	pow_impl< ScalarX, ScalarY, true >
struct	ppolevl
struct	ppolevl< Packet, 0 >
struct	preserve_inner_most_dims
struct	ProdReducer
struct	product_evaluator
struct	product_evaluator< Product< Lhs, Rhs, AliasFreeProduct >, ProductTag, PermutationShape, SparseShape >
struct	product_evaluator< Product< Lhs, Rhs, AliasFreeProduct >, ProductTag, SparseShape, PermutationShape >
struct	product_evaluator< Product< Lhs, Rhs, DefaultProduct >, LazyCoeffBasedProductMode, DenseShape, DenseShape >
struct	product_evaluator< Product< Lhs, Rhs, DefaultProduct >, OuterProduct, DenseShape, SparseShape >
struct	product_evaluator< Product< Lhs, Rhs, DefaultProduct >, OuterProduct, SparseShape, DenseShape >
struct	product_evaluator< Product< Lhs, Rhs, DefaultProduct >, ProductTag, DiagonalShape, SparseShape >
struct	product_evaluator< Product< Lhs, Rhs, DefaultProduct >, ProductTag, SparseShape, DiagonalShape >
struct	product_evaluator< Product< Lhs, Rhs, LazyProduct >, ProductTag, DenseShape, DenseShape >
struct	product_evaluator< Product< Lhs, Rhs, LazyProduct >, ProductTag, DenseShape, HomogeneousShape >
struct	product_evaluator< Product< Lhs, Rhs, LazyProduct >, ProductTag, HomogeneousShape, DenseShape >
struct	product_evaluator< Product< Lhs, Rhs, Options >, ProductTag, LhsShape, RhsShape >
struct	product_evaluator< Product< Lhs, Rhs, ProductKind >, ProductTag, DenseShape, DiagonalShape >
struct	product_evaluator< Product< Lhs, Rhs, ProductKind >, ProductTag, DiagonalShape, DenseShape >
struct	product_evaluator< Product< Lhs, RhsView, DefaultProduct >, ProductTag, SparseShape, SparseSelfAdjointShape >
struct	product_evaluator< Product< LhsView, Rhs, DefaultProduct >, ProductTag, SparseSelfAdjointShape, SparseShape >
struct	product_op
struct	product_promote_storage_type
struct	product_promote_storage_type< A, A, ProductTag >
struct	product_promote_storage_type< A, Dense, ProductTag >
struct	product_promote_storage_type< A, DiagonalShape, ProductTag >
struct	product_promote_storage_type< A, PermutationStorage, ProductTag >
struct	product_promote_storage_type< Dense, B, ProductTag >
struct	product_promote_storage_type< Dense, Dense, ProductTag >
struct	product_promote_storage_type< Dense, DiagonalShape, ProductTag >
struct	product_promote_storage_type< Dense, PermutationStorage, ProductTag >
struct	product_promote_storage_type< Dense, Sparse, OuterProduct >
struct	product_promote_storage_type< DiagonalShape, B, ProductTag >
struct	product_promote_storage_type< DiagonalShape, Dense, ProductTag >
struct	product_promote_storage_type< PermutationStorage, B, ProductTag >
struct	product_promote_storage_type< PermutationStorage, Dense, ProductTag >
struct	product_promote_storage_type< PermutationStorage, Sparse, ProductTag >
struct	product_promote_storage_type< Sparse, Dense, OuterProduct >
struct	product_promote_storage_type< Sparse, PermutationStorage, ProductTag >
struct	product_selfadjoint_matrix
struct	product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, false, ConjugateLhs, RhsStorageOrder, true, ConjugateRhs, ColMajor, ResInnerStride >
struct	product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, LhsSelfAdjoint, ConjugateLhs, RhsStorageOrder, RhsSelfAdjoint, ConjugateRhs, RowMajor, ResInnerStride >
struct	product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, true, ConjugateLhs, RhsStorageOrder, false, ConjugateRhs, ColMajor, ResInnerStride >
struct	product_size_category
struct	product_triangular_matrix_matrix
struct	product_triangular_matrix_matrix< Scalar, Index, Mode, false, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor, ResInnerStride, Version >
struct	product_triangular_matrix_matrix< Scalar, Index, Mode, LhsIsTriangular, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, RowMajor, ResInnerStride, Version >
struct	product_triangular_matrix_matrix< Scalar, Index, Mode, true, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor, ResInnerStride, Version >
struct	product_triangular_matrix_matrix_trmm
struct	product_type
struct	product_type_selector
struct	product_type_selector< 1, 1, 1 >
struct	product_type_selector< 1, 1, Depth >
struct	product_type_selector< 1, Large, Large >
struct	product_type_selector< 1, Large, Small >
struct	product_type_selector< 1, N, 1 >
struct	product_type_selector< 1, Small, Large >
struct	product_type_selector< 1, Small, Small >
struct	product_type_selector< Large, 1, Large >
struct	product_type_selector< Large, 1, Small >
struct	product_type_selector< Large, Large, Large >
struct	product_type_selector< Large, Large, Small >
struct	product_type_selector< Large, Small, 1 >
struct	product_type_selector< Large, Small, Large >
struct	product_type_selector< Large, Small, Small >
struct	product_type_selector< M, 1, 1 >
struct	product_type_selector< M, N, 1 >
struct	product_type_selector< Small, 1, Large >
struct	product_type_selector< Small, 1, Small >
struct	product_type_selector< Small, Large, 1 >
struct	product_type_selector< Small, Large, Large >
struct	product_type_selector< Small, Large, Small >
struct	product_type_selector< Small, Small, 1 >
struct	product_type_selector< Small, Small, Large >
struct	product_type_selector< Small, Small, Small >
struct	projective_transform_inverse
struct	projective_transform_inverse< TransformType, Projective >
struct	promote_index_type
struct	promote_scalar_arg
struct	promote_scalar_arg< S, T, false >
struct	promote_scalar_arg< S, T, true >
struct	promote_scalar_arg_unsupported
struct	promote_scalar_arg_unsupported< ExprScalar, T, PromotedType, false, true >
struct	promote_scalar_arg_unsupported< S, T, PromotedType, ConvertibleToLiteral, false >
struct	promote_scalar_arg_unsupported< S, T, PromotedType, true, true >
struct	promote_scalar_arg_unsupported< S, T, S, false, true >
struct	promote_storage_type
struct	promote_storage_type< A, A >
struct	promote_storage_type< A, const A >
struct	promote_storage_type< const A, A >
struct	pselect_impl
struct	pselect_impl< Packet, typename internal::enable_if< is_scalar< Packet >::value >::type >
struct	ptrue_impl
struct	ptrue_impl< T, typename internal::enable_if< is_scalar< T >::value &&NumTraits< T >::RequireInitialization >::type >
struct	pzero_impl
struct	pzero_impl< T, typename internal::enable_if< is_scalar< T >::value >::type >
struct	qr_preconditioner_impl
class	qr_preconditioner_impl< MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true >
class	qr_preconditioner_impl< MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true >
class	qr_preconditioner_impl< MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true >
class	qr_preconditioner_impl< MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true >
class	qr_preconditioner_impl< MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true >
class	qr_preconditioner_impl< MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true >
class	qr_preconditioner_impl< MatrixType, QRPreconditioner, Case, false >
struct	qr_preconditioner_should_do_anything
struct	quad_traits
struct	quad_traits< double >
struct	QuadPacket
struct	quat_conj
struct	quat_conj< Architecture::Target, Derived, float >
struct	quat_product
struct	quat_product< Architecture::Target, Derived, OtherDerived, float >
struct	quaternionbase_assign_impl
struct	quaternionbase_assign_impl< Other, 3, 3 >
struct	quaternionbase_assign_impl< Other, 4, 1 >
struct	random_default_impl
struct	random_default_impl< bfloat16, false, false >
struct	random_default_impl< half, false, false >
struct	random_default_impl< Scalar, false, false >
struct	random_default_impl< Scalar, false, true >
struct	random_default_impl< Scalar, true, false >
struct	random_impl
struct	random_impl< bool >
struct	random_retval
struct	random_without_cast_overflow
struct	random_without_cast_overflow< SrcScalar, TgtScalar, typename internal::enable_if< !NumTraits< SrcScalar >::IsInteger &&!NumTraits< SrcScalar >::IsComplex &&NumTraits< TgtScalar >::IsInteger &&(std::numeric_limits< TgtScalar >::digits > std::numeric_limits< SrcScalar >::digits)>::type >
struct	random_without_cast_overflow< SrcScalar, TgtScalar, typename internal::enable_if< !NumTraits< SrcScalar >::IsInteger &&!NumTraits< SrcScalar >::IsComplex &&NumTraits< TgtScalar >::IsInteger &&(std::numeric_limits< TgtScalar >::digits<=std::numeric_limits< SrcScalar >::digits)>::type >
struct	random_without_cast_overflow< SrcScalar, TgtScalar, typename internal::enable_if< NumTraits< SrcScalar >::IsComplex &&!NumTraits< TgtScalar >::IsComplex >::type >
struct	random_without_cast_overflow< SrcScalar, TgtScalar, typename internal::enable_if< NumTraits< SrcScalar >::IsComplex &&NumTraits< TgtScalar >::IsComplex >::type >
struct	random_without_cast_overflow< SrcScalar, TgtScalar, typename internal::enable_if< NumTraits< SrcScalar >::IsInteger &&!NumTraits< TgtScalar >::IsInteger &&!NumTraits< TgtScalar >::IsComplex >::type >
struct	random_without_cast_overflow< SrcScalar, TgtScalar, typename internal::enable_if< NumTraits< SrcScalar >::IsInteger &&NumTraits< TgtScalar >::IsInteger &&!NumTraits< SrcScalar >::IsSigned &&(std::numeric_limits< SrcScalar >::digits > std::numeric_limits< TgtScalar >::digits)>::type >
struct	random_without_cast_overflow< SrcScalar, TgtScalar, typename internal::enable_if< NumTraits< SrcScalar >::IsInteger &&NumTraits< TgtScalar >::IsInteger &&!NumTraits< SrcScalar >::IsSigned &&NumTraits< TgtScalar >::IsSigned &&(std::numeric_limits< SrcScalar >::digits==std::numeric_limits< TgtScalar >::digits)>::type >
struct	random_without_cast_overflow< SrcScalar, TgtScalar, typename internal::enable_if< NumTraits< SrcScalar >::IsInteger &&NumTraits< TgtScalar >::IsInteger &&!NumTraits< TgtScalar >::IsSigned &&(std::numeric_limits< SrcScalar >::digits< std::numeric_limits< TgtScalar >::digits||(std::numeric_limits< SrcScalar >::digits==std::numeric_limits< TgtScalar >::digits &&NumTraits< SrcScalar >::IsSigned))>::type >
struct	random_without_cast_overflow< SrcScalar, TgtScalar, typename internal::enable_if< NumTraits< SrcScalar >::IsInteger &&NumTraits< TgtScalar >::IsInteger &&NumTraits< SrcScalar >::IsSigned &&(std::numeric_limits< SrcScalar >::digits > std::numeric_limits< TgtScalar >::digits)>::type >
struct	random_without_cast_overflow< SrcScalar, TgtScalar, typename internal::enable_if<!NumTraits< SrcScalar >::IsComplex &&NumTraits< TgtScalar >::IsComplex >::type >
struct	random_without_cast_overflow< SrcScalar, TgtScalar, typename internal::enable_if<!NumTraits< SrcScalar >::IsInteger &&!NumTraits< SrcScalar >::IsComplex &&!NumTraits< TgtScalar >::IsInteger &&!NumTraits< TgtScalar >::IsComplex &&(std::numeric_limits< SrcScalar >::digits > std::numeric_limits< TgtScalar >::digits)>::type >
struct	rcond_compute_sign
struct	rcond_compute_sign< Vector, Vector, false >
struct	real_default_impl
struct	real_default_impl< Scalar, true >
struct	real_impl
struct	real_ref_impl
struct	real_ref_retval
struct	real_retval
struct	reduce
struct	reduce< Reducer >
struct	reduce< Reducer, A >
struct	reduce< Reducer, A, Ts... >
struct	ReduceBlock
struct	ReduceBlock< Self, true, false >
struct	reducer_traits
struct	reducer_traits< AndReducer, Device >
struct	reducer_traits< ArgMaxTupleReducer< T >, Device >
struct	reducer_traits< ArgMinTupleReducer< T >, Device >
struct	reducer_traits< MaxReducer< T, NaNPropagation >, Device >
struct	reducer_traits< MeanReducer< T >, Device >
struct	reducer_traits< MinReducer< T, NaNPropagation >, Device >
struct	reducer_traits< OrReducer, Device >
struct	reducer_traits< ProdReducer< T >, Device >
struct	reducer_traits< SumReducer< T >, Device >
struct	ReductionReturnType
class	redux_evaluator
struct	redux_impl
struct	redux_impl< Func, Evaluator, DefaultTraversal, CompleteUnrolling >
struct	redux_impl< Func, Evaluator, DefaultTraversal, NoUnrolling >
struct	redux_impl< Func, Evaluator, LinearVectorizedTraversal, CompleteUnrolling >
struct	redux_impl< Func, Evaluator, LinearVectorizedTraversal, NoUnrolling >
struct	redux_impl< Func, Evaluator, SliceVectorizedTraversal, Unrolling >
struct	redux_novec_unroller
struct	redux_novec_unroller< Func, Evaluator, Start, 0 >
struct	redux_novec_unroller< Func, Evaluator, Start, 1 >
struct	redux_traits
struct	redux_vec_unroller
struct	redux_vec_unroller< Func, Evaluator, Start, 0 >
struct	redux_vec_unroller< Func, Evaluator, Start, 1 >
struct	ref_selector
struct	remove_all
struct	remove_all< const T >
struct	remove_all< T & >
struct	remove_all< T * >
struct	remove_all< T const & >
struct	remove_all< T const * >
struct	remove_const
struct	remove_const< const T >
struct	remove_const< const T[]>
struct	remove_const< const T[Size]>
struct	remove_pointer
struct	remove_pointer< T * >
struct	remove_pointer< T *const >
struct	remove_reference
struct	remove_reference< T & >
struct	reshaped_evaluator
struct	reshaped_evaluator< ArgType, Rows, Cols, Order, false >
struct	reshaped_evaluator< ArgType, Rows, Cols, Order, true >
class	ReshapedImpl_dense
class	ReshapedImpl_dense< XprType, Rows, Cols, Order, false >
class	ReshapedImpl_dense< XprType, Rows, Cols, Order, true >
class	restricted_packet_dense_assignment_kernel
struct	result_of
struct	result_of< Func(ArgType)>
struct	result_of< Func(ArgType0, ArgType1)>
struct	result_of< Func(ArgType0, ArgType1, ArgType2)>
struct	result_of< scalar_cmp_op< LhsScalar, RhsScalar, Cmp >(LhsScalar, RhsScalar)>
struct	reverse_packet_cond
struct	reverse_packet_cond< PacketType, false >
struct	RhsPanelHelper
struct	rint_impl
struct	rint_impl< double >
struct	rint_impl< float >
struct	rint_retval
struct	rotation_base_generic_product_selector
struct	rotation_base_generic_product_selector< RotationDerived, DiagonalMatrix< Scalar, Dim, MaxDim >, false >
struct	rotation_base_generic_product_selector< RotationDerived, MatrixType, false >
struct	rotation_base_generic_product_selector< RotationDerived, OtherVectorType, true >
struct	round_impl
struct	round_impl< double >
struct	round_impl< float >
struct	round_retval
struct	round_using_floor_ceil_impl
struct	rsqrt_impl
struct	rsqrt_impl< std::complex< T > >
struct	rsqrt_retval
struct	scalar_abs2_op
struct	scalar_abs_op
struct	scalar_absolute_difference_op
struct	scalar_acos_op
struct	scalar_arg_op
struct	scalar_asin_op
struct	scalar_atan_op
struct	scalar_bessel_i0_op
struct	scalar_bessel_i0e_op
struct	scalar_bessel_i1_op
struct	scalar_bessel_i1e_op
struct	scalar_bessel_j0_op
struct	scalar_bessel_j1_op
struct	scalar_bessel_k0_op
struct	scalar_bessel_k0e_op
struct	scalar_bessel_k1_op
struct	scalar_bessel_k1e_op
struct	scalar_bessel_y0_op
struct	scalar_bessel_y1_op
struct	scalar_betainc_op
struct	scalar_boolean_and_op
struct	scalar_boolean_not_op
struct	scalar_boolean_or_op
struct	scalar_boolean_xor_op
struct	scalar_cast_op
struct	scalar_cast_op< Eigen::bfloat16, float >
struct	scalar_cast_op< Eigen::half, float >
struct	scalar_cast_op< float, Eigen::bfloat16 >
struct	scalar_cast_op< float, Eigen::half >
struct	scalar_cast_op< int, Eigen::bfloat16 >
struct	scalar_cast_op< int, Eigen::half >
struct	scalar_ceil_op
struct	scalar_clamp_op
struct	scalar_cmp_op
struct	scalar_cmp_op< LhsScalar, RhsScalar, cmp_EQ >
struct	scalar_cmp_op< LhsScalar, RhsScalar, cmp_GE >
struct	scalar_cmp_op< LhsScalar, RhsScalar, cmp_GT >
struct	scalar_cmp_op< LhsScalar, RhsScalar, cmp_LE >
struct	scalar_cmp_op< LhsScalar, RhsScalar, cmp_LT >
struct	scalar_cmp_op< LhsScalar, RhsScalar, cmp_NEQ >
struct	scalar_cmp_op< LhsScalar, RhsScalar, cmp_UNORD >
struct	scalar_conj_product_op
struct	scalar_conjugate_op
struct	scalar_constant_op
struct	scalar_cos_op
struct	scalar_cosh_op
struct	scalar_cube_op
struct	scalar_cube_op< bool >
struct	scalar_difference_op
struct	scalar_digamma_op
struct	scalar_div_cost
struct	scalar_div_cost< double, true >
struct	scalar_div_cost< float, true >
struct	scalar_div_cost< signed long, Vectorized, typename conditional< sizeof(long)==8, void, false_type >::type >
struct	scalar_div_cost< std::complex< T >, Vectorized >
struct	scalar_div_cost< unsigned long, Vectorized, typename conditional< sizeof(long)==8, void, false_type >::type >
struct	scalar_erf_op
struct	scalar_erfc_op
struct	scalar_exp_op
struct	scalar_expm1_op
struct	scalar_floor_op
struct	scalar_fmod_op
struct	scalar_fuzzy_default_impl
struct	scalar_fuzzy_default_impl< Scalar, false, false >
struct	scalar_fuzzy_default_impl< Scalar, false, true >
struct	scalar_fuzzy_default_impl< Scalar, true, false >
struct	scalar_fuzzy_impl
struct	scalar_fuzzy_impl< bool >
struct	scalar_gamma_sample_der_alpha_op
struct	scalar_hypot_op
struct	scalar_hypot_op< Scalar, Scalar >
struct	scalar_identity_op
struct	scalar_igamma_der_a_op
struct	scalar_igamma_op
struct	scalar_igammac_op
struct	scalar_imag_op
struct	scalar_imag_ref_op
struct	scalar_inverse_op
struct	scalar_isfinite_op
struct	scalar_isinf_op
struct	scalar_isnan_op
struct	scalar_lgamma_op
struct	scalar_log10_op
struct	scalar_log1p_op
struct	scalar_log2_op
struct	scalar_log_op
struct	scalar_logistic_op
struct	scalar_logistic_op< float >
struct	scalar_max_op
struct	scalar_min_op
struct	scalar_mod2_op
struct	scalar_mod_op
struct	scalar_ndtri_op
struct	scalar_opposite_op
struct	scalar_polygamma_op
struct	scalar_pow_op
struct	scalar_product_op
struct	scalar_product_traits
struct	scalar_quotient_op
struct	scalar_random_op
struct	scalar_real_op
struct	scalar_real_ref_op
struct	scalar_rint_op
struct	scalar_round_op
struct	scalar_rsqrt_op
struct	scalar_score_coeff_op
struct	scalar_shift_left_op
struct	scalar_shift_right_op
struct	scalar_sign_op
struct	scalar_sign_op< Scalar, false, false >
struct	scalar_sign_op< Scalar, false, true >
struct	scalar_sign_op< Scalar, true, is_integer >
struct	scalar_sin_op
struct	scalar_sinh_op
struct	scalar_sqrt_op
struct	scalar_sqrt_op< bool >
struct	scalar_square_op
struct	scalar_square_op< bool >
struct	scalar_sum_op
struct	scalar_tan_op
struct	scalar_tanh_op
struct	scalar_zeta_op
struct	ScanLauncher
struct	ScanLauncher< Self, Reducer, Eigen::SyclDevice, vectorize >
class	scoped_array
struct	Selector
struct	selfadjoint_matrix_vector_product
struct	selfadjoint_matrix_vector_product_symv
struct	selfadjoint_product_impl
struct	selfadjoint_product_impl< Lhs, 0, true, Rhs, RhsMode, false >
struct	selfadjoint_product_impl< Lhs, LhsMode, false, Rhs, 0, true >
struct	selfadjoint_product_impl< Lhs, LhsMode, false, Rhs, RhsMode, false >
struct	selfadjoint_rank2_update_selector
struct	selfadjoint_rank2_update_selector< Scalar, Index, UType, VType, Lower >
struct	selfadjoint_rank2_update_selector< Scalar, Index, UType, VType, Upper >
struct	setIdentity_impl
struct	setIdentity_impl< Derived, true >
struct	shuffle_mask
struct	significant_decimals_impl
class	SimpleTensorContractionMapper
struct	simplicial_cholesky_grab_input
struct	simplicial_cholesky_grab_input< MatrixType, MatrixType >
struct	SingleRange
struct	size_at_compile_time
struct	size_of_xpr_at_compile_time
struct	sizes_match_below_dim
struct	sizes_match_below_dim< Dims1, Dims2, 0, 0 >
struct	sizes_match_below_dim< Dims1, Dims2, n, n >
struct	skip
struct	skyline_product_mode
struct	skyline_product_selector
struct	skyline_product_selector< Lhs, Rhs, ResultType, ColMajor >
struct	skyline_product_selector< Lhs, Rhs, ResultType, RowMajor >
class	SkylineProduct
struct	SkylineProductReturnType
struct	slice
struct	smart_copy_helper
struct	smart_copy_helper< T, false >
struct	smart_copy_helper< T, true >
struct	smart_memmove_helper
struct	smart_memmove_helper< T, false >
struct	smart_memmove_helper< T, true >
struct	solve_assertion
struct	solve_assertion< CwiseUnaryOp< Eigen::internal::scalar_conjugate_op< Scalar >, const Transpose< Derived > > >
struct	solve_assertion< Transpose< Derived > >
struct	solve_traits
struct	solve_traits< Decomposition, RhsType, Dense >
struct	solve_traits< Decomposition, RhsType, Sparse >
struct	Sparse2Dense
struct	Sparse2Sparse
struct	sparse_conjunction_evaluator
struct	sparse_conjunction_evaluator< XprType, IndexBased, IteratorBased >
struct	sparse_conjunction_evaluator< XprType, IteratorBased, IndexBased >
struct	sparse_conjunction_evaluator< XprType, IteratorBased, IteratorBased >
struct	sparse_dense_outer_product_evaluator
struct	sparse_diagonal_product_evaluator
struct	sparse_diagonal_product_evaluator< SparseXprType, DiagCoeffType, SDP_AsCwiseProduct >
struct	sparse_diagonal_product_evaluator< SparseXprType, DiagonalCoeffType, SDP_AsScalarProduct >
struct	sparse_eval
struct	sparse_eval< T, 1, 1, Flags >
struct	sparse_eval< T, 1, Cols, Flags >
struct	sparse_eval< T, Rows, 1, Flags >
class	sparse_matrix_block_impl
struct	sparse_solve_triangular_selector
struct	sparse_solve_triangular_selector< Lhs, Rhs, Mode, Lower, ColMajor >
struct	sparse_solve_triangular_selector< Lhs, Rhs, Mode, Lower, RowMajor >
struct	sparse_solve_triangular_selector< Lhs, Rhs, Mode, Upper, ColMajor >
struct	sparse_solve_triangular_selector< Lhs, Rhs, Mode, Upper, RowMajor >
struct	sparse_solve_triangular_sparse_selector
struct	sparse_solve_triangular_sparse_selector< Lhs, Rhs, Mode, UpLo, ColMajor >
struct	sparse_sparse_product_with_pruning_selector
struct	sparse_sparse_product_with_pruning_selector< Lhs, Rhs, ResultType, ColMajor, ColMajor, ColMajor >
struct	sparse_sparse_product_with_pruning_selector< Lhs, Rhs, ResultType, ColMajor, ColMajor, RowMajor >
struct	sparse_sparse_product_with_pruning_selector< Lhs, Rhs, ResultType, ColMajor, RowMajor, ColMajor >
struct	sparse_sparse_product_with_pruning_selector< Lhs, Rhs, ResultType, ColMajor, RowMajor, RowMajor >
struct	sparse_sparse_product_with_pruning_selector< Lhs, Rhs, ResultType, RowMajor, ColMajor, ColMajor >
struct	sparse_sparse_product_with_pruning_selector< Lhs, Rhs, ResultType, RowMajor, ColMajor, RowMajor >
struct	sparse_sparse_product_with_pruning_selector< Lhs, Rhs, ResultType, RowMajor, RowMajor, ColMajor >
struct	sparse_sparse_product_with_pruning_selector< Lhs, Rhs, ResultType, RowMajor, RowMajor, RowMajor >
struct	sparse_sparse_to_dense_product_selector
struct	sparse_sparse_to_dense_product_selector< Lhs, Rhs, ResultType, ColMajor, ColMajor >
struct	sparse_sparse_to_dense_product_selector< Lhs, Rhs, ResultType, ColMajor, RowMajor >
struct	sparse_sparse_to_dense_product_selector< Lhs, Rhs, ResultType, RowMajor, ColMajor >
struct	sparse_sparse_to_dense_product_selector< Lhs, Rhs, ResultType, RowMajor, RowMajor >
struct	sparse_time_dense_product_impl
struct	sparse_time_dense_product_impl< SparseLhsType, DenseRhsType, DenseResType, AlphaType, ColMajor, true >
struct	sparse_time_dense_product_impl< SparseLhsType, DenseRhsType, DenseResType, typename DenseResType::Scalar, ColMajor, false >
struct	sparse_time_dense_product_impl< SparseLhsType, DenseRhsType, DenseResType, typename DenseResType::Scalar, RowMajor, false >
struct	sparse_time_dense_product_impl< SparseLhsType, DenseRhsType, DenseResType, typename DenseResType::Scalar, RowMajor, true >
struct	sparse_vector_assign_selector
struct	sparse_vector_assign_selector< Dest, Src, SVA_Inner >
struct	sparse_vector_assign_selector< Dest, Src, SVA_Outer >
struct	sparse_vector_assign_selector< Dest, Src, SVA_RuntimeSwitch >
class	SparseLUImpl
class	SparseRefBase
struct	SparseSelfAdjoint2Sparse
struct	SparseSelfAdjointShape
class	SparseTransposeImpl
class	SparseTransposeImpl< MatrixType, CompressedAccessBit >
struct	SparseTriangularShape
struct	sqrt_impl
struct	sqrt_impl< std::complex< T > >
struct	sqrt_retval
struct	static_assertion
struct	static_assertion< true >
struct	static_val
struct	stem_function
struct	storage_kind_to_evaluator_kind
struct	storage_kind_to_evaluator_kind< Sparse >
struct	storage_kind_to_shape
struct	storage_kind_to_shape< Dense >
struct	storage_kind_to_shape< DiagonalShape >
struct	storage_kind_to_shape< PermutationStorage >
struct	storage_kind_to_shape< SolverStorage >
struct	storage_kind_to_shape< Sparse >
struct	storage_kind_to_shape< TranspositionsStorage >
class	StridedLinearBufferCopy
struct	sub_assign_op
class	subvector_stl_iterator
class	subvector_stl_reverse_iterator
struct	sum_op
struct	SumReducer
struct	svd_precondition_2x2_block_to_be_real
struct	svd_precondition_2x2_block_to_be_real< MatrixType, QRPreconditioner, false >
struct	svd_precondition_2x2_block_to_be_real< MatrixType, QRPreconditioner, true >
struct	sve_packet_size_selector
struct	swap_assign_op
struct	sycl_packet_traits
struct	symbolic_last_tag
struct	symm_pack_lhs
struct	symm_pack_lhs< double, Index, Pack1, Pack2_dummy, StorageOrder >
struct	symm_pack_lhs< float, Index, Pack1, Pack2_dummy, StorageOrder >
struct	symm_pack_lhs< std::complex< double >, Index, Pack1, Pack2_dummy, StorageOrder >
struct	symm_pack_lhs< std::complex< float >, Index, Pack1, Pack2_dummy, StorageOrder >
struct	symm_pack_rhs
struct	symm_pack_rhs< double, Index, nr, StorageOrder >
struct	symm_pack_rhs< float, Index, nr, StorageOrder >
struct	symm_pack_rhs< std::complex< double >, Index, nr, StorageOrder >
struct	symm_pack_rhs< std::complex< float >, Index, nr, StorageOrder >
struct	take
struct	take< 0, numeric_list< T > >
struct	take< 0, numeric_list< T, a, as... > >
struct	take< 0, type_list< a, as... > >
struct	take< 0, type_list<> >
struct	take< n, numeric_list< T > >
struct	take< n, numeric_list< T, a, as... > >
struct	take< n, type_list< a, as... > >
struct	take< n, type_list<> >
struct	take_matrix_for_product
struct	take_matrix_for_product< Transform< Scalar, Dim, Mode, Options > >
struct	take_matrix_for_product< Transform< Scalar, Dim, Projective, Options > >
struct	tensor_index_linearization_helper
struct	tensor_index_linearization_helper< Index, NumIndices, 0, RowMajor >
struct	tensor_static_symgroup
struct	tensor_static_symgroup_do_apply
struct	tensor_static_symgroup_do_apply< internal::type_list< EIGEN_TPL_PP_SPEC_HACK_USE(empty)> >
struct	tensor_static_symgroup_do_apply< internal::type_list< first, next... > >
struct	tensor_static_symgroup_element
struct	tensor_static_symgroup_element_ctor
struct	tensor_static_symgroup_equality
struct	tensor_static_symgroup_identity_ctor
struct	tensor_static_symgroup_if
struct	tensor_static_symgroup_if< true, NumIndices, Gens... >
struct	tensor_static_symgroup_multiply
struct	tensor_static_symgroup_multiply_helper
struct	tensor_static_symgroup_permutate
struct	tensor_static_symgroup_permutate< numeric_list< int, nn... > >
struct	tensor_symmetry_assign_value
struct	tensor_symmetry_calculate_flags
struct	tensor_symmetry_num_indices
struct	tensor_symmetry_num_indices< AntiHermiticity< One_, Two_ >, Sym... >
struct	tensor_symmetry_num_indices< AntiSymmetry< One_, Two_ >, Sym... >
struct	tensor_symmetry_num_indices< Hermiticity< One_, Two_ >, Sym... >
struct	tensor_symmetry_num_indices< Symmetry< One_, Two_ >, Sym... >
struct	tensor_symmetry_pre_analysis
struct	tensor_symmetry_pre_analysis< NumIndices >
struct	tensor_symmetry_pre_analysis< NumIndices, Gen_, Gens_... >
class	tensor_symmetry_value_setter
struct	tensor_vsize_index_linearization_helper
struct	tensor_vsize_index_linearization_helper< Index, NumIndices, 0, RowMajor >
class	TensorAsyncExecutor
class	TensorBlockAssignment
class	TensorBlockDescriptor
class	TensorBlockIO
class	TensorBlockMapper
class	TensorBlockNotImplemented
struct	TensorBlockResourceRequirements
class	TensorBlockScratchAllocator
class	TensorContractionBlocking
struct	TensorContractionBlockMemAllocator
class	TensorContractionInputMapper
struct	TensorContractionInputMapperTrait
struct	TensorContractionInputMapperTrait< TensorContractionInputMapper< Scalar_, Index_, side_, Tensor_, nocontract_t_, contract_t_, packet_size_, inner_dim_contiguous_, inner_dim_reordered_, Alignment_, MakePointer_ > >
struct	TensorContractionKernel
class	TensorContractionSubMapper
class	TensorCwiseBinaryBlock
class	TensorCwiseUnaryBlock
class	TensorExecutor
class	TensorExecutor< Expression, DefaultDevice, true, TiledEvaluation::Off >
class	TensorExecutor< Expression, DefaultDevice, Vectorizable, TiledEvaluation::On >
struct	TensorIntDivisor
class	TensorIntDivisor< int32_t, true >
class	TensorLazyBaseEvaluator
class	TensorLazyEvaluator
class	TensorLazyEvaluatorReadOnly
class	TensorLazyEvaluatorWritable
class	TensorMaterializedBlock
struct	TensorPrinter
struct	TensorPrinter< Tensor, 0 >
struct	TensorPrinter< Tensor, 1 >
class	TensorTernaryExprBlock
struct	TensorUInt128
class	TensorUnaryExprBlock
struct	ternary_evaluator
struct	ternary_evaluator< CwiseTernaryOp< TernaryOp, Arg1, Arg2, Arg3 >, IndexBased, IndexBased >
struct	ternary_result_of_select
struct	ternary_result_of_select< Func, ArgType0, ArgType1, ArgType2, sizeof(has_std_result_type)>
struct	ternary_result_of_select< Func, ArgType0, ArgType1, ArgType2, sizeof(has_tr1_result)>
struct	ThreadLocalNoOpInitialize
struct	ThreadLocalNoOpRelease
struct	traits
struct	traits< AngleAxis< _Scalar > >
struct	traits< Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > >
struct	traits< ArrayWrapper< ExpressionType > >
struct	traits< BandMatrix< _Scalar, _Rows, _Cols, _Supers, _Subs, _Options > >
struct	traits< BandMatrixWrapper< _CoefficientsType, _Rows, _Cols, _Supers, _Subs, _Options > >
struct	traits< BDCSVD< _MatrixType > >
struct	traits< BiCGSTAB< _MatrixType, _Preconditioner > >
struct	traits< Block< XprType, BlockRows, BlockCols, InnerPanel > >
struct	traits< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _Index > >
struct	traits< BlockSparseMatrixView< BlockSparseMatrixT > >
struct	traits< BlockSparseTimeDenseProduct< BlockSparseMatrixT, VecType > >
struct	traits< ColPivHouseholderQR< _MatrixType > >
struct	traits< CompleteOrthogonalDecomposition< _MatrixType > >
struct	traits< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >
struct	traits< const T >
struct	traits< CwiseBinaryOp< BinaryOp, Lhs, Rhs > >
struct	traits< CwiseNullaryOp< NullaryOp, PlainObjectType > >
struct	traits< CwiseTernaryOp< TernaryOp, Arg1, Arg2, Arg3 > >
struct	traits< CwiseUnaryOp< UnaryOp, XprType > >
struct	traits< CwiseUnaryView< ViewOp, MatrixType > >
struct	traits< DGMRES< _MatrixType, _Preconditioner > >
struct	traits< Diagonal< const SparseMatrix< _Scalar, _Options, _StorageIndex >, DiagIndex > >
struct	traits< Diagonal< MatrixType, DiagIndex > >
struct	traits< Diagonal< SparseMatrix< _Scalar, _Options, _StorageIndex >, DiagIndex > >
struct	traits< DiagonalMatrix< _Scalar, SizeAtCompileTime, MaxSizeAtCompileTime > >
struct	traits< DiagonalWrapper< _DiagonalVectorType > >
struct	traits< DynamicSparseMatrix< _Scalar, _Options, _StorageIndex > >
struct	traits< Eigen::IDRS< _MatrixType, _Preconditioner > >
struct	traits< EulerAngles< _Scalar, _System > >
struct	traits< EvalToTemp< ArgType > >
struct	traits< ForceAlignedAccess< ExpressionType > >
struct	traits< FullPivHouseholderQR< _MatrixType > >
struct	traits< FullPivHouseholderQRMatrixQReturnType< MatrixType > >
struct	traits< FullPivLU< _MatrixType > >
struct	traits< GMRES< _MatrixType, _Preconditioner > >
struct	traits< HessenbergDecompositionMatrixHReturnType< MatrixType > >
struct	traits< Homogeneous< MatrixType, Direction > >
struct	traits< homogeneous_left_product_impl< Homogeneous< MatrixType, Vertical >, Lhs > >
struct	traits< homogeneous_right_product_impl< Homogeneous< MatrixType, Horizontal >, Rhs > >
struct	traits< HouseholderQR< _MatrixType > >
struct	traits< HouseholderSequence< VectorsType, CoeffsType, Side > >
struct	traits< image_retval_base< DecompositionType > >
struct	traits< IndexedView< XprType, RowIndices, ColIndices > >
struct	traits< Inverse< CompleteOrthogonalDecomposition< MatrixType > > >
struct	traits< Inverse< XprType > >
struct	traits< JacobiSVD< _MatrixType, QRPreconditioner > >
struct	traits< kernel_retval_base< DecompositionType > >
struct	traits< KroneckerProduct< _Lhs, _Rhs > >
struct	traits< KroneckerProductSparse< _Lhs, _Rhs > >
struct	traits< LDLT< _MatrixType, _UpLo > >
struct	traits< LeastSquaresConjugateGradient< _MatrixType, _Preconditioner > >
struct	traits< LLT< _MatrixType, _UpLo > >
struct	traits< Map< const Quaternion< _Scalar >, _Options > >
struct	traits< Map< const SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType > >
struct	traits< Map< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex >, _PacketAccess > >
struct	traits< Map< PlainObjectType, MapOptions, StrideType > >
struct	traits< Map< Quaternion< _Scalar >, _Options > >
struct	traits< Map< SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType > >
struct	traits< Map< Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex >, _PacketAccess > >
struct	traits< MappedSparseMatrix< _Scalar, _Flags, _StorageIndex > >
struct	traits< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > >
struct	traits< MatrixExponentialReturnValue< Derived > >
struct	traits< MatrixReplacement >
struct	traits< MatrixSquareRootReturnValue< Derived > >
struct	traits< MatrixWrapper< ExpressionType > >
struct	traits< MINRES< _MatrixType, _UpLo, _Preconditioner > >
struct	traits< NestByValue< ExpressionType > >
struct	traits< PartialPivLU< _MatrixType > >
struct	traits< PartialReduxExpr< MatrixType, MemberOp, Direction > >
struct	traits< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex > >
struct	traits< PermutationWrapper< _IndicesType > >
struct	traits< Product< Lhs, Rhs, Option > >
struct	traits< Quaternion< _Scalar, _Options > >
struct	traits< Ref< _PlainObjectType, _Options, _StrideType > >
struct	traits< Ref< const SparseMatrix< MatScalar, MatOptions, MatIndex >, _Options, _StrideType > >
struct	traits< Ref< const SparseVector< MatScalar, MatOptions, MatIndex >, _Options, _StrideType > >
struct	traits< Ref< SparseMatrix< MatScalar, MatOptions, MatIndex >, _Options, _StrideType > >
struct	traits< Ref< SparseVector< MatScalar, MatOptions, MatIndex >, _Options, _StrideType > >
struct	traits< RefBase< Derived > >
struct	traits< Replicate< MatrixType, RowFactor, ColFactor > >
struct	traits< Reshaped< XprType, Rows, Cols, Order > >
struct	traits< ReturnByValue< Derived > >
struct	traits< Reverse< MatrixType, Direction > >
struct	traits< Rotation2D< _Scalar > >
struct	traits< Select< ConditionMatrixType, ThenMatrixType, ElseMatrixType > >
struct	traits< SelfAdjointView< MatrixType, UpLo > >
struct	traits< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >
struct	traits< SimplicialLDLT< _MatrixType, _UpLo, _Ordering > >
struct	traits< SimplicialLLT< _MatrixType, _UpLo, _Ordering > >
struct	traits< SkylineMatrix< _Scalar, _Options > >
struct	traits< SkylineProduct< LhsNested, RhsNested, ProductMode > >
struct	traits< Solve< Decomposition, RhsType > >
struct	traits< SolveWithGuess< Decomposition, RhsType, GuessType > >
struct	traits< SparseCompressedBase< Derived > >
struct	traits< SparseMatrix< _Scalar, _Options, _StorageIndex > >
struct	traits< SparseQR_QProduct< SparseQRType, Derived > >
struct	traits< SparseQRMatrixQReturnType< SparseQRType > >
struct	traits< SparseQRMatrixQTransposeReturnType< SparseQRType > >
struct	traits< SparseRefBase< Derived > >
struct	traits< SparseSelfAdjointView< MatrixType, Mode > >
struct	traits< SparseSymmetricPermutationProduct< MatrixType, Mode > >
struct	traits< SparseVector< _Scalar, _Options, _StorageIndex > >
struct	traits< SparseView< MatrixType > >
struct	traits< SPQR_QProduct< SPQRType, Derived > >
struct	traits< SPQRMatrixQReturnType< SPQRType > >
struct	traits< SPQRMatrixQTransposeReturnType< SPQRType > >
struct	traits< SVDBase< Derived > >
struct	traits< Tensor< Scalar_, NumIndices_, Options_, IndexType_ > >
struct	traits< TensorAssignOp< LhsXprType, RhsXprType > >
struct	traits< TensorBroadcastingOp< Broadcast, XprType > >
struct	traits< TensorChippingOp< DimId, XprType > >
struct	traits< TensorConcatenationOp< Axis, LhsXprType, RhsXprType > >
struct	traits< TensorContractionOp< Dimensions, LhsXprType, RhsXprType, OutputKernelType > >
struct	traits< TensorConversionOp< TargetType, XprType > >
struct	traits< TensorConvolutionOp< Dimensions, InputXprType, KernelXprType > >
struct	traits< TensorCustomBinaryOp< CustomBinaryFunc, LhsXprType, RhsXprType > >
struct	traits< TensorCustomUnaryOp< CustomUnaryFunc, XprType > >
struct	traits< TensorCwiseBinaryOp< BinaryOp, LhsXprType, RhsXprType > >
struct	traits< TensorCwiseNullaryOp< NullaryOp, XprType > >
struct	traits< TensorCwiseTernaryOp< TernaryOp, Arg1XprType, Arg2XprType, Arg3XprType > >
struct	traits< TensorCwiseUnaryOp< UnaryOp, XprType > >
struct	traits< TensorEvalToOp< XprType, MakePointer_ > >
struct	traits< TensorEvaluator< const TensorContractionOp< Indices_, LeftArgType_, RightArgType_, OutputKernelType_ >, Device_ > >
struct	traits< TensorFFTOp< FFT, XprType, FFTResultType, FFTDir > >
struct	traits< TensorFixedSize< Scalar_, Dimensions, Options_, IndexType_ > >
struct	traits< TensorForcedEvalOp< XprType > >
struct	traits< TensorGeneratorOp< Generator, XprType > >
struct	traits< TensorImagePatchOp< Rows, Cols, XprType > >
struct	traits< TensorIndexTupleOp< XprType > >
struct	traits< TensorInflationOp< Strides, XprType > >
struct	traits< TensorLayoutSwapOp< XprType > >
struct	traits< TensorMap< PlainObjectType, Options_, MakePointer_ > >
struct	traits< TensorPaddingOp< PaddingDimensions, XprType > >
struct	traits< TensorPatchOp< PatchDim, XprType > >
struct	traits< TensorReductionOp< Op, Dims, XprType, MakePointer_ > >
struct	traits< TensorRef< PlainObjectType > >
struct	traits< TensorReshapingOp< NewDimensions, XprType > >
struct	traits< TensorReverseOp< ReverseDimensions, XprType > >
struct	traits< TensorScanOp< Op, XprType > >
struct	traits< TensorSelectOp< IfXprType, ThenXprType, ElseXprType > >
struct	traits< TensorShufflingOp< Shuffle, XprType > >
struct	traits< TensorSlicingOp< StartIndices, Sizes, XprType > >
struct	traits< TensorStridingOp< Strides, XprType > >
struct	traits< TensorStridingSlicingOp< StartIndices, StopIndices, Strides, XprType > >
struct	traits< TensorTraceOp< Dims, XprType > >
struct	traits< TensorTupleReducerOp< ReduceOp, Dims, XprType > >
struct	traits< TensorVolumePatchOp< Planes, Rows, Cols, XprType > >
struct	traits< Transform< _Scalar, _Dim, _Mode, _Options > >
struct	traits< Transpose< MatrixType > >
struct	traits< Transpose< TranspositionsBase< Derived > > >
struct	traits< Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex > >
struct	traits< TranspositionsWrapper< _IndicesType > >
struct	traits< triangular_solve_retval< Side, TriangularType, Rhs > >
struct	traits< TriangularView< MatrixType, _Mode > >
struct	traits< TridiagonalizationMatrixTReturnType< MatrixType > >
struct	traits< VectorBlock< VectorType, Size > >
struct	transfer_constness
struct	transform_construct_from_matrix
struct	transform_construct_from_matrix< Other, AffineCompact, Options, Dim, HDim, HDim, HDim >
struct	transform_construct_from_matrix< Other, Mode, Options, Dim, HDim, Dim, Dim >
struct	transform_construct_from_matrix< Other, Mode, Options, Dim, HDim, Dim, HDim >
struct	transform_construct_from_matrix< Other, Mode, Options, Dim, HDim, HDim, HDim >
struct	transform_left_product_impl
struct	transform_left_product_impl< Other, AffineCompact, Options, Dim, HDim, Dim, HDim >
struct	transform_left_product_impl< Other, AffineCompact, Options, Dim, HDim, HDim, HDim >
struct	transform_left_product_impl< Other, Mode, Options, Dim, HDim, Dim, Dim >
struct	transform_left_product_impl< Other, Mode, Options, Dim, HDim, Dim, HDim >
struct	transform_left_product_impl< Other, Mode, Options, Dim, HDim, HDim, HDim >
struct	transform_make_affine
struct	transform_make_affine< AffineCompact >
struct	transform_product_result
struct	transform_right_product_impl
struct	transform_right_product_impl< TransformType, MatrixType, 0, RhsCols >
struct	transform_right_product_impl< TransformType, MatrixType, 1, RhsCols >
struct	transform_right_product_impl< TransformType, MatrixType, 2, 1 >
struct	transform_right_product_impl< TransformType, MatrixType, 2, RhsCols >
struct	transform_rotation_impl
struct	transform_rotation_impl< Isometry >
struct	transform_take_affine_part
struct	transform_take_affine_part< Transform< Scalar, Dim, AffineCompact, Options > >
struct	transform_traits
struct	transform_transform_product_impl
struct	transform_transform_product_impl< Transform< Scalar, Dim, AffineCompact, LhsOptions >, Transform< Scalar, Dim, Projective, RhsOptions >, true >
struct	transform_transform_product_impl< Transform< Scalar, Dim, LhsMode, LhsOptions >, Transform< Scalar, Dim, RhsMode, RhsOptions >, false >
struct	transform_transform_product_impl< Transform< Scalar, Dim, LhsMode, LhsOptions >, Transform< Scalar, Dim, RhsMode, RhsOptions >, true >
struct	transform_transform_product_impl< Transform< Scalar, Dim, Projective, LhsOptions >, Transform< Scalar, Dim, AffineCompact, RhsOptions >, true >
struct	TransposeImpl_base
struct	TransposeImpl_base< MatrixType, false >
struct	transposition_matrix_product
struct	Triangular2Dense
struct	Triangular2Triangular
struct	triangular_assignment_loop
struct	triangular_assignment_loop< Kernel, Mode, 0, SetOpposite >
struct	triangular_assignment_loop< Kernel, Mode, Dynamic, SetOpposite >
class	triangular_dense_assignment_kernel
class	triangular_dense_assignment_kernel< UpLo, SelfAdjoint, SetOpposite, DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version >
struct	triangular_matrix_vector_product
struct	triangular_matrix_vector_product< Index, Mode, LhsScalar, ConjLhs, RhsScalar, ConjRhs, ColMajor, Version >
struct	triangular_matrix_vector_product< Index, Mode, LhsScalar, ConjLhs, RhsScalar, ConjRhs, RowMajor, Version >
struct	triangular_matrix_vector_product_trmv
struct	triangular_product_impl
struct	triangular_product_impl< Mode, false, Lhs, true, Rhs, false >
struct	triangular_product_impl< Mode, LhsIsTriangular, Lhs, false, Rhs, false >
struct	triangular_product_impl< Mode, true, Lhs, false, Rhs, true >
struct	triangular_solve_matrix
struct	triangular_solve_matrix< Scalar, Index, OnTheLeft, Mode, Conjugate, TriStorageOrder, ColMajor, OtherInnerStride >
struct	triangular_solve_matrix< Scalar, Index, OnTheRight, Mode, Conjugate, TriStorageOrder, ColMajor, OtherInnerStride >
struct	triangular_solve_matrix< Scalar, Index, Side, Mode, Conjugate, TriStorageOrder, RowMajor, OtherInnerStride >
struct	triangular_solve_retval
struct	triangular_solve_vector
struct	triangular_solve_vector< LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, ColMajor >
struct	triangular_solve_vector< LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, RowMajor >
struct	triangular_solve_vector< LhsScalar, RhsScalar, Index, OnTheRight, Mode, Conjugate, StorageOrder >
struct	triangular_solver_selector
struct	triangular_solver_selector< Lhs, Rhs, OnTheLeft, Mode, CompleteUnrolling, 1 >
struct	triangular_solver_selector< Lhs, Rhs, OnTheRight, Mode, CompleteUnrolling, 1 >
struct	triangular_solver_selector< Lhs, Rhs, Side, Mode, NoUnrolling, 1 >
struct	triangular_solver_selector< Lhs, Rhs, Side, Mode, NoUnrolling, Dynamic >
struct	triangular_solver_unroller
struct	triangular_solver_unroller< Lhs, Rhs, Mode, LoopIndex, Size, false >
struct	triangular_solver_unroller< Lhs, Rhs, Mode, LoopIndex, Size, true >
struct	tribb_kernel
struct	tridiagonalization_inplace_selector
struct	tridiagonalization_inplace_selector< MatrixType, 1, IsComplex >
struct	tridiagonalization_inplace_selector< MatrixType, 3, false >
struct	TridiagonalizationMatrixTReturnType
class	TridiagonalMatrix
	Represents a tridiagonal matrix with a compact banded storage. More...
struct	TripletComp
struct	trmv_selector
struct	trmv_selector< Mode, ColMajor >
struct	trmv_selector< Mode, RowMajor >
class	trsolve_traits
struct	true_type
struct	type_casting_traits
struct	type_casting_traits< bfloat16, float >
struct	type_casting_traits< bfloat16, unsigned short int >
struct	type_casting_traits< double, float >
struct	type_casting_traits< Eigen::half, float >
struct	type_casting_traits< float, bfloat16 >
struct	type_casting_traits< float, double >
struct	type_casting_traits< float, Eigen::half >
struct	type_casting_traits< float, float >
struct	type_casting_traits< float, half >
struct	type_casting_traits< float, int >
struct	type_casting_traits< float, numext::int16_t >
struct	type_casting_traits< float, numext::int32_t >
struct	type_casting_traits< float, numext::int64_t >
struct	type_casting_traits< float, numext::int8_t >
struct	type_casting_traits< float, numext::uint16_t >
struct	type_casting_traits< float, numext::uint32_t >
struct	type_casting_traits< float, numext::uint64_t >
struct	type_casting_traits< float, numext::uint8_t >
struct	type_casting_traits< half, float >
struct	type_casting_traits< int, float >
struct	type_casting_traits< numext::int16_t, float >
struct	type_casting_traits< numext::int16_t, numext::int16_t >
struct	type_casting_traits< numext::int16_t, numext::int32_t >
struct	type_casting_traits< numext::int16_t, numext::int64_t >
struct	type_casting_traits< numext::int16_t, numext::int8_t >
struct	type_casting_traits< numext::int16_t, numext::uint16_t >
struct	type_casting_traits< numext::int16_t, numext::uint32_t >
struct	type_casting_traits< numext::int16_t, numext::uint64_t >
struct	type_casting_traits< numext::int16_t, numext::uint8_t >
struct	type_casting_traits< numext::int32_t, float >
struct	type_casting_traits< numext::int32_t, numext::int16_t >
struct	type_casting_traits< numext::int32_t, numext::int32_t >
struct	type_casting_traits< numext::int32_t, numext::int64_t >
struct	type_casting_traits< numext::int32_t, numext::int8_t >
struct	type_casting_traits< numext::int32_t, numext::uint16_t >
struct	type_casting_traits< numext::int32_t, numext::uint32_t >
struct	type_casting_traits< numext::int32_t, numext::uint64_t >
struct	type_casting_traits< numext::int32_t, numext::uint8_t >
struct	type_casting_traits< numext::int64_t, float >
struct	type_casting_traits< numext::int64_t, numext::int16_t >
struct	type_casting_traits< numext::int64_t, numext::int32_t >
struct	type_casting_traits< numext::int64_t, numext::int64_t >
struct	type_casting_traits< numext::int64_t, numext::int8_t >
struct	type_casting_traits< numext::int64_t, numext::uint16_t >
struct	type_casting_traits< numext::int64_t, numext::uint32_t >
struct	type_casting_traits< numext::int64_t, numext::uint64_t >
struct	type_casting_traits< numext::int64_t, numext::uint8_t >
struct	type_casting_traits< numext::int8_t, float >
struct	type_casting_traits< numext::int8_t, numext::int16_t >
struct	type_casting_traits< numext::int8_t, numext::int32_t >
struct	type_casting_traits< numext::int8_t, numext::int64_t >
struct	type_casting_traits< numext::int8_t, numext::int8_t >
struct	type_casting_traits< numext::int8_t, numext::uint16_t >
struct	type_casting_traits< numext::int8_t, numext::uint32_t >
struct	type_casting_traits< numext::int8_t, numext::uint64_t >
struct	type_casting_traits< numext::int8_t, numext::uint8_t >
struct	type_casting_traits< numext::uint16_t, float >
struct	type_casting_traits< numext::uint16_t, numext::int16_t >
struct	type_casting_traits< numext::uint16_t, numext::int32_t >
struct	type_casting_traits< numext::uint16_t, numext::int64_t >
struct	type_casting_traits< numext::uint16_t, numext::int8_t >
struct	type_casting_traits< numext::uint16_t, numext::uint16_t >
struct	type_casting_traits< numext::uint16_t, numext::uint32_t >
struct	type_casting_traits< numext::uint16_t, numext::uint64_t >
struct	type_casting_traits< numext::uint16_t, numext::uint8_t >
struct	type_casting_traits< numext::uint32_t, float >
struct	type_casting_traits< numext::uint32_t, numext::int16_t >
struct	type_casting_traits< numext::uint32_t, numext::int32_t >
struct	type_casting_traits< numext::uint32_t, numext::int64_t >
struct	type_casting_traits< numext::uint32_t, numext::int8_t >
struct	type_casting_traits< numext::uint32_t, numext::uint16_t >
struct	type_casting_traits< numext::uint32_t, numext::uint32_t >
struct	type_casting_traits< numext::uint32_t, numext::uint64_t >
struct	type_casting_traits< numext::uint32_t, numext::uint8_t >
struct	type_casting_traits< numext::uint64_t, float >
struct	type_casting_traits< numext::uint64_t, numext::int16_t >
struct	type_casting_traits< numext::uint64_t, numext::int32_t >
struct	type_casting_traits< numext::uint64_t, numext::int64_t >
struct	type_casting_traits< numext::uint64_t, numext::int8_t >
struct	type_casting_traits< numext::uint64_t, numext::uint16_t >
struct	type_casting_traits< numext::uint64_t, numext::uint32_t >
struct	type_casting_traits< numext::uint64_t, numext::uint64_t >
struct	type_casting_traits< numext::uint64_t, numext::uint8_t >
struct	type_casting_traits< numext::uint8_t, float >
struct	type_casting_traits< numext::uint8_t, numext::int16_t >
struct	type_casting_traits< numext::uint8_t, numext::int32_t >
struct	type_casting_traits< numext::uint8_t, numext::int64_t >
struct	type_casting_traits< numext::uint8_t, numext::int8_t >
struct	type_casting_traits< numext::uint8_t, numext::uint16_t >
struct	type_casting_traits< numext::uint8_t, numext::uint32_t >
struct	type_casting_traits< numext::uint8_t, numext::uint64_t >
struct	type_casting_traits< numext::uint8_t, numext::uint8_t >
struct	type_casting_traits< unsigned short int, bfloat16 >
struct	type_list
struct	type_list< t, tt... >
struct	TypeConversion
struct	umeyama_transform_matrix_type
struct	unaligned_dense_assignment_loop
struct	unaligned_dense_assignment_loop< false >
struct	unary_evaluator
struct	unary_evaluator< ArrayWrapper< TArgType > >
struct	unary_evaluator< Block< ArgType, BlockRows, BlockCols, InnerPanel >, IndexBased >
struct	unary_evaluator< Block< ArgType, BlockRows, BlockCols, InnerPanel >, IteratorBased >
struct	unary_evaluator< Block< const SparseMatrix< _Scalar, _Options, _StorageIndex >, BlockRows, BlockCols, true >, IteratorBased >
struct	unary_evaluator< Block< SparseMatrix< _Scalar, _Options, _StorageIndex >, BlockRows, BlockCols, true >, IteratorBased >
struct	unary_evaluator< CwiseUnaryOp< UnaryOp, ArgType >, IndexBased >
struct	unary_evaluator< CwiseUnaryOp< UnaryOp, ArgType >, IteratorBased >
struct	unary_evaluator< CwiseUnaryView< UnaryOp, ArgType >, IndexBased >
struct	unary_evaluator< CwiseUnaryView< ViewOp, ArgType >, IteratorBased >
struct	unary_evaluator< Homogeneous< ArgType, Direction >, IndexBased >
struct	unary_evaluator< IndexedView< ArgType, RowIndices, ColIndices >, IndexBased >
struct	unary_evaluator< MatrixWrapper< TArgType > >
struct	unary_evaluator< Replicate< ArgType, RowFactor, ColFactor > >
struct	unary_evaluator< Reverse< ArgType, Direction > >
struct	unary_evaluator< SparseView< ArgType >, IndexBased >
struct	unary_evaluator< SparseView< ArgType >, IteratorBased >
struct	unary_evaluator< SparseView< Product< Lhs, Rhs, Options > >, IteratorBased >
struct	unary_evaluator< Transpose< ArgType >, IndexBased >
struct	unary_evaluator< Transpose< ArgType >, IteratorBased >
struct	unary_evaluator< TriangularView< MatrixType, Mode >, IndexBased >
struct	unary_result_of_select
struct	unary_result_of_select< Func, ArgType, sizeof(has_std_result_type)>
struct	unary_result_of_select< Func, ArgType, sizeof(has_tr1_result)>
class	UniformRandomGenerator
struct	uniformscaling_times_affine_returntype
struct	unitOrthogonal_selector
struct	unitOrthogonal_selector< Derived, 2 >
struct	unitOrthogonal_selector< Derived, 3 >
struct	unpacket_traits
struct	unpacket_traits< const T >
struct	unpacket_traits< DoublePacket< Packet > >
struct	unpacket_traits< Packet16b >
struct	unpacket_traits< Packet16bf >
struct	unpacket_traits< Packet16c >
struct	unpacket_traits< Packet16f >
struct	unpacket_traits< Packet16h >
struct	unpacket_traits< Packet16i >
struct	unpacket_traits< Packet16uc >
struct	unpacket_traits< Packet1cd >
struct	unpacket_traits< Packet1cf >
struct	unpacket_traits< Packet2cd >
struct	unpacket_traits< Packet2cf >
struct	unpacket_traits< Packet2d >
struct	unpacket_traits< Packet2f >
struct	unpacket_traits< Packet2i >
struct	unpacket_traits< Packet2l >
struct	unpacket_traits< Packet2ui >
struct	unpacket_traits< Packet2ul >
struct	unpacket_traits< Packet4bf >
struct	unpacket_traits< Packet4c >
struct	unpacket_traits< Packet4cd >
struct	unpacket_traits< Packet4cf >
struct	unpacket_traits< Packet4d >
struct	unpacket_traits< Packet4f >
struct	unpacket_traits< Packet4i >
struct	unpacket_traits< Packet4s >
struct	unpacket_traits< Packet4uc >
struct	unpacket_traits< Packet4ui >
struct	unpacket_traits< Packet4us >
struct	unpacket_traits< Packet8bf >
struct	unpacket_traits< Packet8c >
struct	unpacket_traits< Packet8cf >
struct	unpacket_traits< Packet8d >
struct	unpacket_traits< Packet8f >
struct	unpacket_traits< Packet8h >
struct	unpacket_traits< Packet8i >
struct	unpacket_traits< Packet8s >
struct	unpacket_traits< Packet8uc >
struct	unpacket_traits< Packet8us >
struct	unpacket_traits< PacketXf >
struct	unpacket_traits< PacketXi >
class	UpperBidiagonalization
struct	valid_indexed_view_overload
class	variable_if_dynamic
class	variable_if_dynamic< T, Dynamic >
class	variable_if_dynamicindex
class	variable_if_dynamicindex< T, DynamicIndex >
class	VariableAndFixedInt
struct	vector_int_pair
struct	vectorwise_reverse_inplace_impl
struct	vectorwise_reverse_inplace_impl< Horizontal >
struct	vectorwise_reverse_inplace_impl< Vertical >
class	visitor_evaluator
struct	visitor_impl
struct	visitor_impl< Visitor, Derived, 0 >
struct	visitor_impl< Visitor, Derived, 1 >
struct	visitor_impl< Visitor, Derived, Dynamic >
class	vml_assign_traits
struct	XprScalar
struct	XprScalar< void >
struct	zeta_impl
struct	zeta_impl_series
struct	zeta_impl_series< double >
struct	zeta_impl_series< float >
struct	zeta_retval

Typedefs
typedef __vector float	Packet4f
typedef __vector int	Packet4i
typedef __vector unsigned int	Packet4ui
typedef __vector __bool int	Packet4bi
typedef __vector short int	Packet8s
typedef __vector unsigned short int	Packet8us
typedef __vector signed char	Packet16c
typedef __vector unsigned char	Packet16uc
typedef eigen_packet_wrapper< __vector unsigned short int, 0 >	Packet8bf
typedef __m256	Packet8f
typedef __m256i	Packet8i
typedef __m256d	Packet4d
typedef eigen_packet_wrapper< __m128i, 2 >	Packet8h
typedef __m512	Packet16f
typedef __m512i	Packet16i
typedef __m512d	Packet8d
typedef eigen_packet_wrapper< __m256i, 1 >	Packet16h
typedef eigen_packet_wrapper< __m256i, 2 >	Packet16bf
typedef v2f64	Packet2d
typedef v2i64	Packet2l
typedef v2u64	Packet2ul
typedef float32x2_t	Packet2f
typedef eigen_packet_wrapper< int32_t,2 >	Packet4c
typedef int8x8_t	Packet8c
typedef eigen_packet_wrapper< uint32_t,5 >	Packet4uc
typedef uint8x8_t	Packet8uc
typedef int16x4_t	Packet4s
typedef uint16x4_t	Packet4us
typedef int32x2_t	Packet2i
typedef uint32x2_t	Packet2ui
typedef eigen_packet_wrapper< uint16x4_t, 19 >	Packet4bf
typedef eigen_packet_wrapper< __m128i, 1 >	Packet16b
typedef const char *	SsePrefetchPtrType
typedef svint32_t PacketXi	__attribute__((arm_sve_vector_bits(EIGEN_ARM64_SVE_VL)))
typedef std::ptrdiff_t	IntPtr
typedef std::size_t	UIntPtr

Enumerations
enum	SignMatrix { PositiveSemiDef , NegativeSemiDef , ZeroSign , Indefinite }
enum	{ meta_floor_log2_terminate , meta_floor_log2_move_up , meta_floor_log2_move_down , meta_floor_log2_bogus }
enum	PermPermProduct_t { PermPermProduct }
enum	GEBPPacketSizeType { GEBPPacketFull = 0 , GEBPPacketHalf , GEBPPacketQuarter }
enum	GEMVPacketSizeType { GEMVPacketFull = 0 , GEMVPacketHalf , GEMVPacketQuarter }
enum	ComparisonName {   cmp_EQ = 0 , cmp_LT = 1 , cmp_LE = 2 , cmp_UNORD = 3 ,   cmp_NEQ = 4 , cmp_GT = 5 , cmp_GE = 6 }
enum	{ SDP_AsScalarProduct , SDP_AsCwiseProduct }
enum	{ SVA_RuntimeSwitch , SVA_Inner , SVA_Outer }
enum	{ LUNoMarker = 3 }
enum	{ emptyIdxLU = -1 }
enum	MemType {   LUSUP , UCOL , LSUB , USUB ,   LLVL , ULVL }
enum	{ PreconditionIfMoreColsThanRows , PreconditionIfMoreRowsThanCols }
enum class	TensorBlockShapeType { kUniformAllDims , kSkewedInnerDims }
enum	TensorBlockKind { kExpr , kView , kMaterializedInScratch , kMaterializedInOutput }
enum	{ ShardByRow = 0 , ShardByCol = 1 }
enum	{ Rhs = 0 , Lhs = 1 }
enum	TiledEvaluation { Off = 0 , On = 1 }
enum	IgammaComputationMode { VALUE , DERIVATIVE , SAMPLE_DERIVATIVE }

Functions
template<typename _StorageIndex >
cholmod_dense *	cm_solve (int sys, cholmod_factor &L, cholmod_dense &B, cholmod_common &Common)
template<>
cholmod_dense *	cm_solve< SuiteSparse_long > (int sys, cholmod_factor &L, cholmod_dense &B, cholmod_common &Common)
template<typename _StorageIndex >
cholmod_sparse *	cm_spsolve (int sys, cholmod_factor &L, cholmod_sparse &B, cholmod_common &Common)
template<>
cholmod_sparse *	cm_spsolve< SuiteSparse_long > (int sys, cholmod_factor &L, cholmod_sparse &B, cholmod_common &Common)
template<typename _StorageIndex >
int	cm_factorize_p (cholmod_sparse *A, double beta[2], _StorageIndex *fset, std::size_t fsize, cholmod_factor *L, cholmod_common &Common)
template<>
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)
template<>
EIGEN_STRONG_INLINE Packet2cf	pset1< Packet2cf > (const std::complex< float > &from)
template<>
EIGEN_STRONG_INLINE Packet2cf	pload< Packet2cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet2cf	ploadu< Packet2cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet2cf	ploaddup< Packet2cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE void	pstore< std::complex< float > > (std::complex< float > *to, const Packet2cf &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< std::complex< float > > (std::complex< float > *to, const Packet2cf &from)
EIGEN_STRONG_INLINE Packet2cf	pload2 (const std::complex< float > *from0, const std::complex< float > *from1)
template<>
EIGEN_DEVICE_FUNC Packet2cf	pgather< std::complex< float >, Packet2cf > (const std::complex< float > *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< std::complex< float >, Packet2cf > (std::complex< float > *to, const Packet2cf &from, Index stride)
template<>
EIGEN_STRONG_INLINE Packet2cf	padd< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	psub< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pnegate (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pconj (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pand< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	por< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pxor< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pandnot< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE void	prefetch< std::complex< float > > (const std::complex< float > *addr)
template<>
EIGEN_STRONG_INLINE std::complex< float >	pfirst< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	preverse (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux_mul< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pdiv< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pcplxflip< Packet2cf > (const Packet2cf &x)
EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet2cf, 2 > &kernel)
template<>
EIGEN_STRONG_INLINE Packet2cf	pcmp_eq (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	psqrt< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	plog< Packet4f > (const Packet4f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	pexp< Packet4f > (const Packet4f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	psin< Packet4f > (const Packet4f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	pcos< Packet4f > (const Packet4f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	prsqrt< Packet4f > (const Packet4f &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	ptanh< Packet4f > (const Packet4f &x)
template<typename Scalar , typename Index , int StorageOrder>
EIGEN_ALWAYS_INLINE std::complex< Scalar >	getAdjointVal (Index i, Index j, const_blas_data_mapper< std::complex< Scalar >, Index, StorageOrder > &dt)
template<typename Scalar , typename Index , int StorageOrder, int N>
EIGEN_STRONG_INLINE void	symm_pack_complex_rhs_helper (std::complex< Scalar > *blockB, const std::complex< Scalar > *_rhs, Index rhsStride, Index rows, Index cols, Index k2)
template<typename Scalar , typename Index , int StorageOrder>
EIGEN_STRONG_INLINE void	symm_pack_complex_lhs_helper (std::complex< Scalar > *blockA, const std::complex< Scalar > *_lhs, Index lhsStride, Index cols, Index rows)
template<typename Scalar , typename Index , int StorageOrder, int N>
EIGEN_STRONG_INLINE void	symm_pack_rhs_helper (Scalar *blockB, const Scalar *_rhs, Index rhsStride, Index rows, Index cols, Index k2)
template<typename Scalar , typename Index , int StorageOrder>
EIGEN_STRONG_INLINE void	symm_pack_lhs_helper (Scalar *blockA, const Scalar *_lhs, Index lhsStride, Index cols, Index rows)
template<typename Scalar , typename Packet , typename Index >
EIGEN_ALWAYS_INLINE void	storeBlock (Scalar *to, PacketBlock< Packet, 4 > &block)
template<typename Scalar , typename Packet , typename Index >
EIGEN_ALWAYS_INLINE void	storeBlock (Scalar *to, PacketBlock< Packet, 2 > &block)
template<typename Packet , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void	pger_common (PacketBlock< Packet, 4 > *acc, const Packet &lhsV, const Packet *rhsV)
template<typename Packet , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void	pger_common (PacketBlock< Packet, 1 > *acc, const Packet &lhsV, const Packet *rhsV)
template<int N, typename Scalar , typename Packet , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void	pger (PacketBlock< Packet, N > *acc, const Scalar *lhs, const Packet *rhsV)
template<typename Scalar , typename Packet , typename Index >
EIGEN_ALWAYS_INLINE void	loadPacketRemaining (const Scalar *lhs, Packet &lhsV, Index remaining_rows)
template<int N, typename Scalar , typename Packet , typename Index , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void	pger (PacketBlock< Packet, N > *acc, const Scalar *lhs, const Packet *rhsV, Index remaining_rows)
template<int N, typename Packet , bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_ALWAYS_INLINE void	pgerc_common (PacketBlock< Packet, N > *accReal, PacketBlock< Packet, N > *accImag, const Packet &lhsV, const Packet &lhsVi, const Packet *rhsV, const Packet *rhsVi)
template<int N, typename Scalar , typename Packet , bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
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)
template<typename Scalar , typename Packet , typename Index , bool LhsIsReal>
EIGEN_ALWAYS_INLINE void	loadPacketRemaining (const Scalar *lhs_ptr, const Scalar *lhs_ptr_imag, Packet &lhsV, Packet &lhsVi, Index remaining_rows)
template<int N, typename Scalar , typename Packet , typename Index , bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
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, Index remaining_rows)
template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE Packet	ploadLhs (const Scalar *lhs)
template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE void	bsetzero (PacketBlock< Packet, 4 > &acc)
template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE void	bsetzero (PacketBlock< Packet, 1 > &acc)
template<typename Packet >
EIGEN_ALWAYS_INLINE void	bscale (PacketBlock< Packet, 4 > &acc, PacketBlock< Packet, 4 > &accZ, const Packet &pAlpha)
template<typename Packet >
EIGEN_ALWAYS_INLINE void	bscale (PacketBlock< Packet, 1 > &acc, PacketBlock< Packet, 1 > &accZ, const Packet &pAlpha)
template<typename Packet >
EIGEN_ALWAYS_INLINE void	bscalec_common (PacketBlock< Packet, 4 > &acc, PacketBlock< Packet, 4 > &accZ, const Packet &pAlpha)
template<typename Packet >
EIGEN_ALWAYS_INLINE void	bscalec_common (PacketBlock< Packet, 1 > &acc, PacketBlock< Packet, 1 > &accZ, const Packet &pAlpha)
template<typename Packet , int N>
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)
template<typename Packet >
EIGEN_ALWAYS_INLINE void	band (PacketBlock< Packet, 4 > &acc, const Packet &pMask)
template<typename Packet >
EIGEN_ALWAYS_INLINE void	bscalec (PacketBlock< Packet, 4 > &aReal, PacketBlock< Packet, 4 > &aImag, const Packet &bReal, const Packet &bImag, PacketBlock< Packet, 4 > &cReal, PacketBlock< Packet, 4 > &cImag, const Packet &pMask)
template<typename DataMapper , typename Packet , typename Index , const Index accCols, int N, int StorageOrder>
EIGEN_ALWAYS_INLINE void	bload (PacketBlock< Packet, 4 > &acc, const DataMapper &res, Index row, Index col)
template<typename DataMapper , typename Packet , typename Index , const Index accCols, int N, int StorageOrder>
EIGEN_ALWAYS_INLINE void	bload (PacketBlock< Packet, 8 > &acc, const DataMapper &res, Index row, Index col)
template<typename DataMapper , typename Packet , typename Index , const Index accCols, int N, int StorageOrder>
EIGEN_ALWAYS_INLINE void	bload (PacketBlock< Packet, 2 > &acc, const DataMapper &res, Index row, Index col)
template<typename Packet >
EIGEN_ALWAYS_INLINE Packet	bmask (const int remaining_rows)
template<>
EIGEN_ALWAYS_INLINE Packet2d	bmask< Packet2d > (const int remaining_rows)
template<typename Packet >
EIGEN_ALWAYS_INLINE void	bscale (PacketBlock< Packet, 4 > &acc, PacketBlock< Packet, 4 > &accZ, const Packet &pAlpha, const Packet &pMask)
template<typename Packet >
EIGEN_ALWAYS_INLINE void	pbroadcast4_old (const __UNPACK_TYPE__(Packet) *a, Packet &a0, Packet &a1, Packet &a2, Packet &a3)
template<>
EIGEN_ALWAYS_INLINE void	pbroadcast4_old< Packet2d > (const double *a, Packet2d &a0, Packet2d &a1, Packet2d &a2, Packet2d &a3)
template<typename Scalar , typename Packet , typename Index >
EIGEN_ALWAYS_INLINE void	MICRO_EXTRA_COL (const Scalar *&lhs_ptr, const Scalar *&rhs_ptr, PacketBlock< Packet, 1 > &accZero, Index remaining_rows, Index remaining_cols)
template<typename Scalar , typename Packet , typename DataMapper , typename Index , const Index accRows>
EIGEN_STRONG_INLINE void	gemm_extra_col (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index row, Index col, Index remaining_rows, Index remaining_cols, const Packet &pAlpha)
template<typename Scalar , typename Packet , typename Index , const Index accRows>
EIGEN_ALWAYS_INLINE void	MICRO_EXTRA_ROW (const Scalar *&lhs_ptr, const Scalar *&rhs_ptr, PacketBlock< Packet, 4 > &accZero, Index remaining_rows)
template<typename Scalar , typename Packet , typename DataMapper , typename Index , const Index accRows, const Index accCols>
EIGEN_STRONG_INLINE void	gemm_extra_row (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index row, Index col, Index rows, Index cols, Index remaining_rows, const Packet &pAlpha, const Packet &pMask)
template<int unroll_factor, typename Scalar , typename Packet , typename DataMapper , typename Index , const Index accRows, const Index accCols>
EIGEN_STRONG_INLINE void	gemm_unrolled_iteration (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index &row, Index col, const Packet &pAlpha)
template<int unroll_factor, typename Scalar , typename Packet , typename DataMapper , typename Index , const Index accCols>
EIGEN_STRONG_INLINE void	gemm_unrolled_col_iteration (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index &row, Index col, Index remaining_cols, const Packet &pAlpha)
template<typename Scalar , typename Packet , typename DataMapper , typename Index , const Index accCols>
EIGEN_STRONG_INLINE void	gemm_unrolled_col (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index &row, Index rows, Index col, Index remaining_cols, const Packet &pAlpha)
template<typename Scalar , typename Index , typename Packet , typename RhsPacket , typename DataMapper , const Index accRows, const Index accCols>
EIGEN_STRONG_INLINE 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)
template<typename Scalar , typename Packet , typename Index , const Index accRows, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_ALWAYS_INLINE void	MICRO_COMPLEX_EXTRA_COL (const Scalar *&lhs_ptr_real, const Scalar *&lhs_ptr_imag, const Scalar *&rhs_ptr_real, const Scalar *&rhs_ptr_imag, PacketBlock< Packet, 1 > &accReal, PacketBlock< Packet, 1 > &accImag, Index remaining_rows, Index remaining_cols)
template<typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE void	gemm_complex_extra_col (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index strideB, Index row, Index col, Index remaining_rows, Index remaining_cols, const Packet &pAlphaReal, const Packet &pAlphaImag)
template<typename Scalar , typename Packet , typename Index , const Index accRows, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_ALWAYS_INLINE void	MICRO_COMPLEX_EXTRA_ROW (const Scalar *&lhs_ptr_real, const Scalar *&lhs_ptr_imag, const Scalar *&rhs_ptr_real, const Scalar *&rhs_ptr_imag, PacketBlock< Packet, 4 > &accReal, PacketBlock< Packet, 4 > &accImag, Index remaining_rows)
template<typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_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 col, Index rows, Index cols, Index remaining_rows, const Packet &pAlphaReal, const Packet &pAlphaImag, const Packet &pMask)
template<int unroll_factor, typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_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, Index col, const Packet &pAlphaReal, const Packet &pAlphaImag)
template<int unroll_factor, typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE void	gemm_complex_unrolled_col_iteration (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index strideB, Index &row, Index col, Index remaining_cols, const Packet &pAlphaReal, const Packet &pAlphaImag)
template<typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE void	gemm_complex_unrolled_col (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index strideB, Index &row, Index rows, Index col, Index remaining_cols, const Packet &pAlphaReal, const Packet &pAlphaImag)
template<typename LhsScalar , typename RhsScalar , typename Scalarc , typename Scalar , typename Index , typename Packet , typename Packetc , typename RhsPacket , typename DataMapper , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE 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)
template<typename Packet , typename Packetc >
EIGEN_ALWAYS_INLINE void	bcouple_common (PacketBlock< Packet, 4 > &taccReal, PacketBlock< Packet, 4 > &taccImag, PacketBlock< Packetc, 4 > &acc1, PacketBlock< Packetc, 4 > &acc2)
template<typename Packet , typename Packetc >
EIGEN_ALWAYS_INLINE void	bcouple (PacketBlock< Packet, 4 > &taccReal, PacketBlock< Packet, 4 > &taccImag, PacketBlock< Packetc, 8 > &tRes, PacketBlock< Packetc, 4 > &acc1, PacketBlock< Packetc, 4 > &acc2)
template<typename Packet , typename Packetc >
EIGEN_ALWAYS_INLINE void	bcouple_common (PacketBlock< Packet, 1 > &taccReal, PacketBlock< Packet, 1 > &taccImag, PacketBlock< Packetc, 1 > &acc1, PacketBlock< Packetc, 1 > &acc2)
template<typename Packet , typename Packetc >
EIGEN_ALWAYS_INLINE void	bcouple (PacketBlock< Packet, 1 > &taccReal, PacketBlock< Packet, 1 > &taccImag, PacketBlock< Packetc, 2 > &tRes, PacketBlock< Packetc, 1 > &acc1, PacketBlock< Packetc, 1 > &acc2)
template<>
EIGEN_ALWAYS_INLINE void	bcouple_common< Packet2d, Packet1cd > (PacketBlock< Packet2d, 4 > &taccReal, PacketBlock< Packet2d, 4 > &taccImag, PacketBlock< Packet1cd, 4 > &acc1, PacketBlock< Packet1cd, 4 > &acc2)
template<>
EIGEN_ALWAYS_INLINE void	bcouple_common< Packet2d, Packet1cd > (PacketBlock< Packet2d, 1 > &taccReal, PacketBlock< Packet2d, 1 > &taccImag, PacketBlock< Packet1cd, 1 > &acc1, PacketBlock< Packet1cd, 1 > &acc2)
template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE Packet	ploadRhs (const Scalar *rhs)
template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE void	bsetzeroMMA (__vector_quad *acc)
template<typename DataMapper , typename Index , typename Packet , const Index accCols>
EIGEN_ALWAYS_INLINE void	storeAccumulator (Index i, Index j, const DataMapper &data, const Packet &alpha, __vector_quad *acc)
template<typename DataMapper , typename Index , typename Packet , typename Packetc , const Index accColsC, int N>
EIGEN_ALWAYS_INLINE void	storeComplexAccumulator (Index i, Index j, const DataMapper &data, const Packet &alphaReal, const Packet &alphaImag, __vector_quad *accReal, __vector_quad *accImag)
template<typename LhsPacket , typename RhsPacket , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void	pgerMMA (__vector_quad *acc, const RhsPacket &a, const LhsPacket &b)
template<typename LhsPacket , typename RhsPacket , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void	pgerMMA (__vector_quad *acc, const PacketBlock< Packet2d, 2 > &a, const Packet2d &b)
template<typename LhsPacket , typename RhsPacket , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void	pgerMMA (__vector_quad *acc, const __vector_pair &a, const Packet2d &b)
template<typename LhsPacket , typename RhsPacket , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void	pgerMMA (__vector_quad *, const __vector_pair &, const Packet4f &)
template<typename Scalar , typename Packet , typename RhsPacket , bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_ALWAYS_INLINE void	pgercMMA (__vector_quad *accReal, __vector_quad *accImag, const Packet &lhsV, const Packet &lhsVi, const RhsPacket &rhsV, const RhsPacket &rhsVi)
template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE void	ploadRhsMMA (const Scalar *rhs, Packet &rhsV)
template<>
EIGEN_ALWAYS_INLINE void	ploadRhsMMA< double, PacketBlock< Packet2d, 2 > > (const double *rhs, PacketBlock< Packet2d, 2 > &rhsV)
template<>
EIGEN_ALWAYS_INLINE void	ploadRhsMMA< double, __vector_pair > (const double *rhs, __vector_pair &rhsV)
template<>
EIGEN_ALWAYS_INLINE void	ploadRhsMMA (const float *, __vector_pair &)
template<int unroll_factor, typename Scalar , typename Packet , typename RhsPacket , typename DataMapper , typename Index , const Index accRows, const Index accCols>
EIGEN_STRONG_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, Index col, const Packet &pAlpha)
template<typename Scalar , typename Index , typename Packet , typename RhsPacket , typename DataMapper , const Index accRows, const Index accCols>
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)
template<int unroll_factor, typename Scalar , typename Packet , typename Packetc , typename RhsPacket , typename DataMapper , typename Index , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_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, Index col, const Packet &pAlphaReal, const Packet &pAlphaImag)
template<typename LhsScalar , typename RhsScalar , typename Scalarc , typename Scalar , typename Index , typename Packet , typename Packetc , typename RhsPacket , typename DataMapper , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
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)
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 Packet >
EIGEN_STRONG_INLINE Packet	pload_common (const __UNPACK_TYPE__(Packet) *from)
template<>
EIGEN_STRONG_INLINE Packet4f	pload< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4i	pload< Packet4i > (const int *from)
template<>
EIGEN_STRONG_INLINE Packet8s	pload< Packet8s > (const short int *from)
template<>
EIGEN_STRONG_INLINE Packet8us	pload< Packet8us > (const unsigned short int *from)
template<>
EIGEN_STRONG_INLINE Packet16c	pload< Packet16c > (const signed char *from)
template<>
EIGEN_STRONG_INLINE Packet16uc	pload< Packet16uc > (const unsigned char *from)
template<>
EIGEN_STRONG_INLINE Packet8bf	pload< Packet8bf > (const bfloat16 *from)
template<typename Packet >
EIGEN_STRONG_INLINE void	pstore_common (__UNPACK_TYPE__(Packet) *to, const Packet &from)
template<>
EIGEN_STRONG_INLINE void	pstore< float > (float *to, const Packet4f &from)
template<>
EIGEN_STRONG_INLINE void	pstore< int > (int *to, const Packet4i &from)
template<>
EIGEN_STRONG_INLINE void	pstore< short int > (short int *to, const Packet8s &from)
template<>
EIGEN_STRONG_INLINE void	pstore< unsigned short int > (unsigned short int *to, const Packet8us &from)
template<>
EIGEN_STRONG_INLINE void	pstore< bfloat16 > (bfloat16 *to, const Packet8bf &from)
template<>
EIGEN_STRONG_INLINE void	pstore< signed char > (signed char *to, const Packet16c &from)
template<>
EIGEN_STRONG_INLINE void	pstore< unsigned char > (unsigned char *to, const Packet16uc &from)
template<typename Packet >
EIGEN_STRONG_INLINE Packet	pset1_size4 (const __UNPACK_TYPE__(Packet)&from)
template<typename Packet >
EIGEN_STRONG_INLINE Packet	pset1_size8 (const __UNPACK_TYPE__(Packet)&from)
template<typename Packet >
EIGEN_STRONG_INLINE Packet	pset1_size16 (const __UNPACK_TYPE__(Packet)&from)
template<>
EIGEN_STRONG_INLINE Packet4f	pset1< Packet4f > (const float &from)
template<>
EIGEN_STRONG_INLINE Packet4i	pset1< Packet4i > (const int &from)
template<>
EIGEN_STRONG_INLINE Packet8s	pset1< Packet8s > (const short int &from)
template<>
EIGEN_STRONG_INLINE Packet8us	pset1< Packet8us > (const unsigned short int &from)
template<>
EIGEN_STRONG_INLINE Packet16c	pset1< Packet16c > (const signed char &from)
template<>
EIGEN_STRONG_INLINE Packet16uc	pset1< Packet16uc > (const unsigned char &from)
template<>
EIGEN_STRONG_INLINE Packet4f	pset1frombits< Packet4f > (unsigned int from)
template<>
EIGEN_STRONG_INLINE Packet8bf	pset1< Packet8bf > (const bfloat16 &from)
template<typename Packet >
EIGEN_STRONG_INLINE void	pbroadcast4_common (const __UNPACK_TYPE__(Packet) *a, Packet &a0, Packet &a1, Packet &a2, Packet &a3)
template<>
EIGEN_STRONG_INLINE void	pbroadcast4< Packet4f > (const float *a, Packet4f &a0, Packet4f &a1, Packet4f &a2, Packet4f &a3)
template<>
EIGEN_STRONG_INLINE void	pbroadcast4< Packet4i > (const int *a, Packet4i &a0, Packet4i &a1, Packet4i &a2, Packet4i &a3)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pgather_common (const __UNPACK_TYPE__(Packet) *from, Index stride)
template<>
EIGEN_DEVICE_FUNC Packet4f	pgather< float, Packet4f > (const float *from, Index stride)
template<>
EIGEN_DEVICE_FUNC Packet4i	pgather< int, Packet4i > (const int *from, Index stride)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pgather_size8 (const __UNPACK_TYPE__(Packet) *from, Index stride)
template<>
EIGEN_DEVICE_FUNC Packet8s	pgather< short int, Packet8s > (const short int *from, Index stride)
template<>
EIGEN_DEVICE_FUNC Packet8us	pgather< unsigned short int, Packet8us > (const unsigned short int *from, Index stride)
template<>
EIGEN_DEVICE_FUNC Packet8bf	pgather< bfloat16, Packet8bf > (const bfloat16 *from, Index stride)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pgather_size16 (const __UNPACK_TYPE__(Packet) *from, Index stride)
template<>
EIGEN_DEVICE_FUNC Packet16c	pgather< signed char, Packet16c > (const signed char *from, Index stride)
template<>
EIGEN_DEVICE_FUNC Packet16uc	pgather< unsigned char, Packet16uc > (const unsigned char *from, Index stride)
template<typename Packet >
EIGEN_DEVICE_FUNC void	pscatter_size4 (__UNPACK_TYPE__(Packet) *to, const Packet &from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< float, Packet4f > (float *to, const Packet4f &from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< int, Packet4i > (int *to, const Packet4i &from, Index stride)
template<typename Packet >
EIGEN_DEVICE_FUNC void	pscatter_size8 (__UNPACK_TYPE__(Packet) *to, const Packet &from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< short int, Packet8s > (short int *to, const Packet8s &from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< unsigned short int, Packet8us > (unsigned short int *to, const Packet8us &from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< bfloat16, Packet8bf > (bfloat16 *to, const Packet8bf &from, Index stride)
template<typename Packet >
EIGEN_DEVICE_FUNC void	pscatter_size16 (__UNPACK_TYPE__(Packet) *to, const Packet &from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< signed char, Packet16c > (signed char *to, const Packet16c &from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< unsigned char, Packet16uc > (unsigned char *to, const Packet16uc &from, Index stride)
template<>
EIGEN_STRONG_INLINE Packet4f	plset< Packet4f > (const float &a)
template<>
EIGEN_STRONG_INLINE Packet4i	plset< Packet4i > (const int &a)
template<>
EIGEN_STRONG_INLINE Packet8s	plset< Packet8s > (const short int &a)
template<>
EIGEN_STRONG_INLINE Packet8us	plset< Packet8us > (const unsigned short int &a)
template<>
EIGEN_STRONG_INLINE Packet16c	plset< Packet16c > (const signed char &a)
template<>
EIGEN_STRONG_INLINE Packet16uc	plset< Packet16uc > (const unsigned char &a)
template<>
EIGEN_STRONG_INLINE Packet4f	padd< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	padd< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4ui	padd< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_STRONG_INLINE Packet8s	padd< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet8us	padd< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet16c	padd< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	padd< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4f	psub< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	psub< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet8s	psub< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet8us	psub< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet16c	psub< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	psub< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pnegate (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pnegate (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pconj (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pconj (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pmul< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pmul< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pmul< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pmul< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pmul< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pmul< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pdiv< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pdiv< Packet4i > (const Packet4i &, const Packet4i &)
template<>
EIGEN_STRONG_INLINE Packet4f	pmadd (const Packet4f &a, const Packet4f &b, const Packet4f &c)
template<>
EIGEN_STRONG_INLINE Packet4i	pmadd (const Packet4i &a, const Packet4i &b, const Packet4i &c)
template<>
EIGEN_STRONG_INLINE Packet8s	pmadd (const Packet8s &a, const Packet8s &b, const Packet8s &c)
template<>
EIGEN_STRONG_INLINE Packet8us	pmadd (const Packet8us &a, const Packet8us &b, const Packet8us &c)
template<>
EIGEN_STRONG_INLINE Packet4f	pmin< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pmin< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pmin< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pmin< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pmin< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pmin< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pmax< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pmax< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pmax< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pmax< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pmax< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pmax< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pcmp_le (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pcmp_lt (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pcmp_eq (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pcmp_lt_or_nan (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pcmp_le (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pcmp_lt (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pcmp_eq (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pcmp_le (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pcmp_lt (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pcmp_eq (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pcmp_le (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pcmp_lt (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pcmp_eq (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pcmp_le (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pcmp_lt (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pcmp_eq (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pcmp_le (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pcmp_lt (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pcmp_eq (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pand< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pand< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4ui	pand< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pand< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pand< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet4f	por< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	por< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet8s	por< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet8us	por< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	por< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pxor< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pxor< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pxor< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pandnot< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pandnot< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pselect (const Packet4f &mask, const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pround< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pceil< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pfloor< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	print< Packet4f > (const Packet4f &a)
template<typename Packet >
EIGEN_STRONG_INLINE Packet	ploadu_common (const __UNPACK_TYPE__(Packet) *from)
template<>
EIGEN_STRONG_INLINE Packet4f	ploadu< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4i	ploadu< Packet4i > (const int *from)
template<>
EIGEN_STRONG_INLINE Packet8s	ploadu< Packet8s > (const short int *from)
template<>
EIGEN_STRONG_INLINE Packet8us	ploadu< Packet8us > (const unsigned short int *from)
template<>
EIGEN_STRONG_INLINE Packet8bf	ploadu< Packet8bf > (const bfloat16 *from)
template<>
EIGEN_STRONG_INLINE Packet16c	ploadu< Packet16c > (const signed char *from)
template<>
EIGEN_STRONG_INLINE Packet16uc	ploadu< Packet16uc > (const unsigned char *from)
template<typename Packet >
EIGEN_STRONG_INLINE Packet	ploaddup_common (const __UNPACK_TYPE__(Packet) *from)
template<>
EIGEN_STRONG_INLINE Packet4f	ploaddup< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4i	ploaddup< Packet4i > (const int *from)
template<>
EIGEN_STRONG_INLINE Packet8s	ploaddup< Packet8s > (const short int *from)
template<>
EIGEN_STRONG_INLINE Packet8us	ploaddup< Packet8us > (const unsigned short int *from)
template<>
EIGEN_STRONG_INLINE Packet8s	ploadquad< Packet8s > (const short int *from)
template<>
EIGEN_STRONG_INLINE Packet8us	ploadquad< Packet8us > (const unsigned short int *from)
template<>
EIGEN_STRONG_INLINE Packet8bf	ploadquad< Packet8bf > (const bfloat16 *from)
template<>
EIGEN_STRONG_INLINE Packet16c	ploaddup< Packet16c > (const signed char *from)
template<>
EIGEN_STRONG_INLINE Packet16uc	ploaddup< Packet16uc > (const unsigned char *from)
template<typename Packet >
EIGEN_STRONG_INLINE void	pstoreu_common (__UNPACK_TYPE__(Packet) *to, const Packet &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< float > (float *to, const Packet4f &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< int > (int *to, const Packet4i &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< short int > (short int *to, const Packet8s &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< unsigned short int > (unsigned short int *to, const Packet8us &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< bfloat16 > (bfloat16 *to, const Packet8bf &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< signed char > (signed char *to, const Packet16c &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< unsigned char > (unsigned char *to, const Packet16uc &from)
template<>
EIGEN_STRONG_INLINE void	prefetch< float > (const float *addr)
template<>
EIGEN_STRONG_INLINE void	prefetch< int > (const int *addr)
template<>
EIGEN_STRONG_INLINE float	pfirst< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE int	pfirst< Packet4i > (const Packet4i &a)
template<typename Packet >
EIGEN_STRONG_INLINE	__UNPACK_TYPE__ (Packet) pfirst_common(const Packet &a)
template<>
EIGEN_STRONG_INLINE short int	pfirst< Packet8s > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE unsigned short int	pfirst< Packet8us > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE signed char	pfirst< Packet16c > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE unsigned char	pfirst< Packet16uc > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE Packet4f	preverse (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4i	preverse (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet8s	preverse (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE Packet8us	preverse (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE Packet16c	preverse (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE Packet16uc	preverse (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	preverse (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pabs (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pabs (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet8s	pabs (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE Packet8us	pabs (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE Packet16c	pabs (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE Packet16uc	pabs (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	pabs (const Packet8bf &a)
template<int N>
EIGEN_STRONG_INLINE Packet4i	parithmetic_shift_right (const Packet4i &a)
template<int N>
EIGEN_STRONG_INLINE Packet4i	plogical_shift_right (const Packet4i &a)
template<int N>
EIGEN_STRONG_INLINE Packet4i	plogical_shift_left (const Packet4i &a)
template<int N>
EIGEN_STRONG_INLINE Packet4f	plogical_shift_left (const Packet4f &a)
template<int N>
EIGEN_STRONG_INLINE Packet4f	plogical_shift_right (const Packet4f &a)
template<int N>
EIGEN_STRONG_INLINE Packet4ui	plogical_shift_right (const Packet4ui &a)
template<int N>
EIGEN_STRONG_INLINE Packet4ui	plogical_shift_left (const Packet4ui &a)
template<int N>
EIGEN_STRONG_INLINE Packet8us	plogical_shift_left (const Packet8us &a)
template<int N>
EIGEN_STRONG_INLINE Packet8us	plogical_shift_right (const Packet8us &a)
EIGEN_STRONG_INLINE Packet4f	Bf16ToF32Even (const Packet8bf &bf)
EIGEN_STRONG_INLINE Packet4f	Bf16ToF32Odd (const Packet8bf &bf)
EIGEN_STRONG_INLINE Packet8bf	F32ToBf16Bool (Packet4f even, Packet4f odd)
EIGEN_STRONG_INLINE Packet8bf	F32ToBf16 (Packet4f p4f)
EIGEN_STRONG_INLINE Packet8bf	F32ToBf16 (Packet4f even, Packet4f odd)
template<>
EIGEN_STRONG_INLINE Packet8bf	padd< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pmul< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pdiv< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pnegate< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	psub< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	psqrt< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	prsqrt< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	pexp< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pldexp< Packet4f > (const Packet4f &a, const Packet4f &exponent)
template<>
EIGEN_STRONG_INLINE Packet8bf	pldexp< Packet8bf > (const Packet8bf &a, const Packet8bf &exponent)
template<>
EIGEN_STRONG_INLINE Packet4f	pfrexp< Packet4f > (const Packet4f &a, Packet4f &exponent)
template<>
EIGEN_STRONG_INLINE Packet8bf	pfrexp< Packet8bf > (const Packet8bf &a, Packet8bf &e)
template<>
EIGEN_STRONG_INLINE Packet8bf	psin< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	pcos< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	plog< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	pfloor< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	pceil< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	pround< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	print< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	pmadd (const Packet8bf &a, const Packet8bf &b, const Packet8bf &c)
template<>
EIGEN_STRONG_INLINE Packet8bf	pmin< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pmax< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pcmp_lt (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pcmp_lt_or_nan (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pcmp_le (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pcmp_eq (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE bfloat16	pfirst (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	ploaddup< Packet8bf > (const bfloat16 *from)
template<>
EIGEN_STRONG_INLINE Packet8bf	plset< Packet8bf > (const bfloat16 &a)
template<>
EIGEN_STRONG_INLINE float	predux< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE int	predux< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE bfloat16	predux< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE short int	predux< Packet8s > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE unsigned short int	predux< Packet8us > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE signed char	predux< Packet16c > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE unsigned char	predux< Packet16uc > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE float	predux_mul< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE int	predux_mul< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE short int	predux_mul< Packet8s > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE unsigned short int	predux_mul< Packet8us > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE bfloat16	predux_mul< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE signed char	predux_mul< Packet16c > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE unsigned char	predux_mul< Packet16uc > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE float	predux_min< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE int	predux_min< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE bfloat16	predux_min< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE short int	predux_min< Packet8s > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE unsigned short int	predux_min< Packet8us > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE signed char	predux_min< Packet16c > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE unsigned char	predux_min< Packet16uc > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE float	predux_max< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE int	predux_max< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE bfloat16	predux_max< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE short int	predux_max< Packet8s > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE unsigned short int	predux_max< Packet8us > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE signed char	predux_max< Packet16c > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE unsigned char	predux_max< Packet16uc > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE bool	predux_any (const Packet4f &x)
template<typename T >
EIGEN_DEVICE_FUNC void	ptranpose_common (PacketBlock< T, 4 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet4f, 4 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet4i, 4 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet8s, 4 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet8us, 4 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet8bf, 4 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet16c, 4 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet16uc, 4 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet8s, 8 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet8us, 8 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet8bf, 8 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet16c, 16 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet16uc, 16 > &kernel)
template<typename Packet >
EIGEN_STRONG_INLINE Packet	pblend4 (const Selector< 4 > &ifPacket, const Packet &thenPacket, const Packet &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet4i	pblend (const Selector< 4 > &ifPacket, const Packet4i &thenPacket, const Packet4i &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet4f	pblend (const Selector< 4 > &ifPacket, const Packet4f &thenPacket, const Packet4f &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet8s	pblend (const Selector< 8 > &ifPacket, const Packet8s &thenPacket, const Packet8s &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet8us	pblend (const Selector< 8 > &ifPacket, const Packet8us &thenPacket, const Packet8us &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet8bf	pblend (const Selector< 8 > &ifPacket, const Packet8bf &thenPacket, const Packet8bf &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet16c	pblend (const Selector< 16 > &ifPacket, const Packet16c &thenPacket, const Packet16c &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet16uc	pblend (const Selector< 16 > &ifPacket, const Packet16uc &thenPacket, const Packet16uc &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet4i	pcast< Packet4f, Packet4i > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4ui	pcast< Packet4f, Packet4ui > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pcast< Packet4i, Packet4f > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pcast< Packet4ui, Packet4f > (const Packet4ui &a)
template<>
EIGEN_STRONG_INLINE Packet8us	pcast< Packet8bf, Packet8us > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	pcast< Packet8us, Packet8bf > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE Packet4i	preinterpret< Packet4i, Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	preinterpret< Packet4f, Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4cf	padd< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
template<>
EIGEN_STRONG_INLINE Packet4cf	psub< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
template<>
EIGEN_STRONG_INLINE Packet4cf	pnegate (const Packet4cf &a)
template<>
EIGEN_STRONG_INLINE Packet4cf	pconj (const Packet4cf &a)
template<>
EIGEN_STRONG_INLINE Packet4cf	pmul< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
template<>
EIGEN_STRONG_INLINE Packet4cf	pcmp_eq (const Packet4cf &a, const Packet4cf &b)
template<>
EIGEN_STRONG_INLINE Packet4cf	ptrue< Packet4cf > (const Packet4cf &a)
template<>
EIGEN_STRONG_INLINE Packet4cf	pand< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
template<>
EIGEN_STRONG_INLINE Packet4cf	por< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
template<>
EIGEN_STRONG_INLINE Packet4cf	pxor< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
template<>
EIGEN_STRONG_INLINE Packet4cf	pandnot< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
template<>
EIGEN_STRONG_INLINE Packet4cf	pload< Packet4cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet4cf	ploadu< Packet4cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet4cf	pset1< Packet4cf > (const std::complex< float > &from)
template<>
EIGEN_STRONG_INLINE Packet4cf	ploaddup< Packet4cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE void	pstore< std::complex< float > > (std::complex< float > *to, const Packet4cf &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< std::complex< float > > (std::complex< float > *to, const Packet4cf &from)
template<>
EIGEN_DEVICE_FUNC Packet4cf	pgather< std::complex< float >, Packet4cf > (const std::complex< float > *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< std::complex< float >, Packet4cf > (std::complex< float > *to, const Packet4cf &from, Index stride)
template<>
EIGEN_STRONG_INLINE std::complex< float >	pfirst< Packet4cf > (const Packet4cf &a)
template<>
EIGEN_STRONG_INLINE Packet4cf	preverse (const Packet4cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux< Packet4cf > (const Packet4cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux_mul< Packet4cf > (const Packet4cf &a)
template<>
EIGEN_STRONG_INLINE Packet4cf	pdiv< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
template<>
EIGEN_STRONG_INLINE Packet4cf	pcplxflip< Packet4cf > (const Packet4cf &x)
template<>
EIGEN_STRONG_INLINE Packet2cd	padd< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cd	psub< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cd	pnegate (const Packet2cd &a)
template<>
EIGEN_STRONG_INLINE Packet2cd	pconj (const Packet2cd &a)
template<>
EIGEN_STRONG_INLINE Packet2cd	pmul< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cd	pcmp_eq (const Packet2cd &a, const Packet2cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cd	ptrue< Packet2cd > (const Packet2cd &a)
template<>
EIGEN_STRONG_INLINE Packet2cd	pand< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cd	por< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cd	pxor< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cd	pandnot< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cd	pload< Packet2cd > (const std::complex< double > *from)
template<>
EIGEN_STRONG_INLINE Packet2cd	ploadu< Packet2cd > (const std::complex< double > *from)
template<>
EIGEN_STRONG_INLINE Packet2cd	pset1< Packet2cd > (const std::complex< double > &from)
template<>
EIGEN_STRONG_INLINE Packet2cd	ploaddup< Packet2cd > (const std::complex< double > *from)
template<>
EIGEN_STRONG_INLINE void	pstore< std::complex< double > > (std::complex< double > *to, const Packet2cd &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< std::complex< double > > (std::complex< double > *to, const Packet2cd &from)
template<>
EIGEN_DEVICE_FUNC Packet2cd	pgather< std::complex< double >, Packet2cd > (const std::complex< double > *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< std::complex< double >, Packet2cd > (std::complex< double > *to, const Packet2cd &from, Index stride)
template<>
EIGEN_STRONG_INLINE std::complex< double >	pfirst< Packet2cd > (const Packet2cd &a)
template<>
EIGEN_STRONG_INLINE Packet2cd	preverse (const Packet2cd &a)
template<>
EIGEN_STRONG_INLINE std::complex< double >	predux< Packet2cd > (const Packet2cd &a)
template<>
EIGEN_STRONG_INLINE std::complex< double >	predux_mul< Packet2cd > (const Packet2cd &a)
template<>
EIGEN_STRONG_INLINE Packet2cd	pdiv< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cd	pcplxflip< Packet2cd > (const Packet2cd &x)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet4cf, 4 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet2cd, 2 > &kernel)
template<>
EIGEN_STRONG_INLINE Packet2cd	psqrt< Packet2cd > (const Packet2cd &a)
template<>
EIGEN_STRONG_INLINE Packet4cf	psqrt< Packet4cf > (const Packet4cf &a)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f	psin< Packet8f > (const Packet8f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f	pcos< Packet8f > (const Packet8f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f	plog< Packet8f > (const Packet8f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d	plog< Packet4d > (const Packet4d &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f	plog2< Packet8f > (const Packet8f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d	plog2< Packet4d > (const Packet4d &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f	plog1p< Packet8f > (const Packet8f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f	pexpm1< Packet8f > (const Packet8f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f	pexp< Packet8f > (const Packet8f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f	ptanh< Packet8f > (const Packet8f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d	pexp< Packet4d > (const Packet4d &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f	psqrt< Packet8f > (const Packet8f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d	psqrt< Packet4d > (const Packet4d &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f	prsqrt< Packet8f > (const Packet8f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d	prsqrt< Packet4d > (const Packet4d &_x)
template<>
EIGEN_STRONG_INLINE Packet8h	pfrexp (const Packet8h &a, Packet8h &exponent)
template<>
EIGEN_STRONG_INLINE Packet8h	pldexp (const Packet8h &a, const Packet8h &exponent)
template<>
EIGEN_STRONG_INLINE Packet8bf	pfrexp (const Packet8bf &a, Packet8bf &exponent)
template<>
EIGEN_STRONG_INLINE Packet8bf	pldexp (const Packet8bf &a, const Packet8bf &exponent)
EIGEN_STRONG_INLINE __m128i	Pack16To8 (Packet8f rf)
template<>
EIGEN_STRONG_INLINE Packet8f	pset1< Packet8f > (const float &from)
template<>
EIGEN_STRONG_INLINE Packet4d	pset1< Packet4d > (const double &from)
template<>
EIGEN_STRONG_INLINE Packet8i	pset1< Packet8i > (const int &from)
template<>
EIGEN_STRONG_INLINE Packet8f	pset1frombits< Packet8f > (unsigned int from)
template<>
EIGEN_STRONG_INLINE Packet4d	pset1frombits< Packet4d > (uint64_t from)
template<>
EIGEN_STRONG_INLINE Packet8f	pzero (const Packet8f &)
template<>
EIGEN_STRONG_INLINE Packet4d	pzero (const Packet4d &)
template<>
EIGEN_STRONG_INLINE Packet8i	pzero (const Packet8i &)
template<>
EIGEN_STRONG_INLINE Packet8f	peven_mask (const Packet8f &)
template<>
EIGEN_STRONG_INLINE Packet8i	peven_mask (const Packet8i &)
template<>
EIGEN_STRONG_INLINE Packet4d	peven_mask (const Packet4d &)
template<>
EIGEN_STRONG_INLINE Packet8f	pload1< Packet8f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4d	pload1< Packet4d > (const double *from)
template<>
EIGEN_STRONG_INLINE Packet8f	plset< Packet8f > (const float &a)
template<>
EIGEN_STRONG_INLINE Packet4d	plset< Packet4d > (const double &a)
template<>
EIGEN_STRONG_INLINE Packet8f	padd< Packet8f > (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet4d	padd< Packet4d > (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet8i	padd< Packet8i > (const Packet8i &a, const Packet8i &b)
template<>
EIGEN_STRONG_INLINE Packet8f	psub< Packet8f > (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet4d	psub< Packet4d > (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet8i	psub< Packet8i > (const Packet8i &a, const Packet8i &b)
template<>
EIGEN_STRONG_INLINE Packet8f	pnegate (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE Packet4d	pnegate (const Packet4d &a)
template<>
EIGEN_STRONG_INLINE Packet8f	pconj (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE Packet4d	pconj (const Packet4d &a)
template<>
EIGEN_STRONG_INLINE Packet8i	pconj (const Packet8i &a)
template<>
EIGEN_STRONG_INLINE Packet8f	pmul< Packet8f > (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet4d	pmul< Packet4d > (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet8i	pmul< Packet8i > (const Packet8i &a, const Packet8i &b)
template<>
EIGEN_STRONG_INLINE Packet8f	pdiv< Packet8f > (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet4d	pdiv< Packet4d > (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet8i	pdiv< Packet8i > (const Packet8i &, const Packet8i &)
template<>
EIGEN_STRONG_INLINE Packet8f	pcmp_le (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet8f	pcmp_lt (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet8f	pcmp_lt_or_nan (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet8f	pcmp_eq (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet4d	pcmp_le (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet4d	pcmp_lt (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet4d	pcmp_lt_or_nan (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet4d	pcmp_eq (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet8i	pcmp_eq (const Packet8i &a, const Packet8i &b)
template<>
EIGEN_STRONG_INLINE Packet8f	pmin< Packet8f > (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet4d	pmin< Packet4d > (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet8f	pmax< Packet8f > (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet4d	pmax< Packet4d > (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet8f	pmin< PropagateNumbers, Packet8f > (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet4d	pmin< PropagateNumbers, Packet4d > (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet8f	pmax< PropagateNumbers, Packet8f > (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet4d	pmax< PropagateNumbers, Packet4d > (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet8f	pmin< PropagateNaN, Packet8f > (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet4d	pmin< PropagateNaN, Packet4d > (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet8f	pmax< PropagateNaN, Packet8f > (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet4d	pmax< PropagateNaN, Packet4d > (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet8f	print< Packet8f > (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE Packet4d	print< Packet4d > (const Packet4d &a)
template<>
EIGEN_STRONG_INLINE Packet8f	pceil< Packet8f > (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE Packet4d	pceil< Packet4d > (const Packet4d &a)
template<>
EIGEN_STRONG_INLINE Packet8f	pfloor< Packet8f > (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE Packet4d	pfloor< Packet4d > (const Packet4d &a)
template<>
EIGEN_STRONG_INLINE Packet8i	ptrue< Packet8i > (const Packet8i &a)
template<>
EIGEN_STRONG_INLINE Packet8f	ptrue< Packet8f > (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE Packet4d	ptrue< Packet4d > (const Packet4d &a)
template<>
EIGEN_STRONG_INLINE Packet8f	pand< Packet8f > (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet4d	pand< Packet4d > (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet8i	pand< Packet8i > (const Packet8i &a, const Packet8i &b)
template<>
EIGEN_STRONG_INLINE Packet8f	por< Packet8f > (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet4d	por< Packet4d > (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet8i	por< Packet8i > (const Packet8i &a, const Packet8i &b)
template<>
EIGEN_STRONG_INLINE Packet8f	pxor< Packet8f > (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet4d	pxor< Packet4d > (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet8i	pxor< Packet8i > (const Packet8i &a, const Packet8i &b)
template<>
EIGEN_STRONG_INLINE Packet8f	pandnot< Packet8f > (const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet4d	pandnot< Packet4d > (const Packet4d &a, const Packet4d &b)
template<>
EIGEN_STRONG_INLINE Packet8i	pandnot< Packet8i > (const Packet8i &a, const Packet8i &b)
template<>
EIGEN_STRONG_INLINE Packet8f	pround< Packet8f > (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE Packet4d	pround< Packet4d > (const Packet4d &a)
template<>
EIGEN_STRONG_INLINE Packet8f	pselect< Packet8f > (const Packet8f &mask, const Packet8f &a, const Packet8f &b)
template<>
EIGEN_STRONG_INLINE Packet4d	pselect< Packet4d > (const Packet4d &mask, const Packet4d &a, const Packet4d &b)
template<int N>
EIGEN_STRONG_INLINE Packet8i	parithmetic_shift_right (Packet8i a)
template<int N>
EIGEN_STRONG_INLINE Packet8i	plogical_shift_right (Packet8i a)
template<int N>
EIGEN_STRONG_INLINE Packet8i	plogical_shift_left (Packet8i a)
template<>
EIGEN_STRONG_INLINE Packet8f	pload< Packet8f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4d	pload< Packet4d > (const double *from)
template<>
EIGEN_STRONG_INLINE Packet8i	pload< Packet8i > (const int *from)
template<>
EIGEN_STRONG_INLINE Packet8f	ploadu< Packet8f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4d	ploadu< Packet4d > (const double *from)
template<>
EIGEN_STRONG_INLINE Packet8i	ploadu< Packet8i > (const int *from)
template<>
EIGEN_STRONG_INLINE Packet8f	ploadu< Packet8f > (const float *from, uint8_t umask)
template<>
EIGEN_STRONG_INLINE Packet8f	ploaddup< Packet8f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4d	ploaddup< Packet4d > (const double *from)
template<>
EIGEN_STRONG_INLINE Packet8f	ploadquad< Packet8f > (const float *from)
template<>
EIGEN_STRONG_INLINE void	pstore< float > (float *to, const Packet8f &from)
template<>
EIGEN_STRONG_INLINE void	pstore< double > (double *to, const Packet4d &from)
template<>
EIGEN_STRONG_INLINE void	pstore< int > (int *to, const Packet8i &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< float > (float *to, const Packet8f &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< double > (double *to, const Packet4d &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< int > (int *to, const Packet8i &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< float > (float *to, const Packet8f &from, uint8_t umask)
template<>
EIGEN_DEVICE_FUNC Packet8f	pgather< float, Packet8f > (const float *from, Index stride)
template<>
EIGEN_DEVICE_FUNC Packet4d	pgather< double, Packet4d > (const double *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< float, Packet8f > (float *to, const Packet8f &from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< double, Packet4d > (double *to, const Packet4d &from, Index stride)
template<>
EIGEN_STRONG_INLINE void	pstore1< Packet8f > (float *to, const float &a)
template<>
EIGEN_STRONG_INLINE void	pstore1< Packet4d > (double *to, const double &a)
template<>
EIGEN_STRONG_INLINE void	pstore1< Packet8i > (int *to, const int &a)
template<>
EIGEN_STRONG_INLINE void	prefetch< float > (const float *addr)
template<>
EIGEN_STRONG_INLINE void	prefetch< double > (const double *addr)
template<>
EIGEN_STRONG_INLINE void	prefetch< int > (const int *addr)
template<>
EIGEN_STRONG_INLINE float	pfirst< Packet8f > (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE double	pfirst< Packet4d > (const Packet4d &a)
template<>
EIGEN_STRONG_INLINE int	pfirst< Packet8i > (const Packet8i &a)
template<>
EIGEN_STRONG_INLINE Packet8f	preverse (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE Packet4d	preverse (const Packet4d &a)
template<>
EIGEN_STRONG_INLINE Packet8f	pabs (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE Packet4d	pabs (const Packet4d &a)
template<>
EIGEN_STRONG_INLINE Packet8f	pfrexp< Packet8f > (const Packet8f &a, Packet8f &exponent)
template<>
EIGEN_STRONG_INLINE Packet4d	pfrexp_generic_get_biased_exponent (const Packet4d &a)
template<>
EIGEN_STRONG_INLINE Packet4d	pfrexp< Packet4d > (const Packet4d &a, Packet4d &exponent)
template<>
EIGEN_STRONG_INLINE Packet8f	pldexp< Packet8f > (const Packet8f &a, const Packet8f &exponent)
template<>
EIGEN_STRONG_INLINE Packet4d	pldexp< Packet4d > (const Packet4d &a, const Packet4d &exponent)
template<>
EIGEN_STRONG_INLINE float	predux< Packet8f > (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE double	predux< Packet4d > (const Packet4d &a)
template<>
EIGEN_STRONG_INLINE Packet4f	predux_half_dowto4< Packet8f > (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE float	predux_mul< Packet8f > (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE double	predux_mul< Packet4d > (const Packet4d &a)
template<>
EIGEN_STRONG_INLINE float	predux_min< Packet8f > (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE double	predux_min< Packet4d > (const Packet4d &a)
template<>
EIGEN_STRONG_INLINE float	predux_max< Packet8f > (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE double	predux_max< Packet4d > (const Packet4d &a)
template<>
EIGEN_STRONG_INLINE bool	predux_any (const Packet8f &x)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet8f, 8 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet8f, 4 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet4d, 4 > &kernel)
template<>
EIGEN_STRONG_INLINE Packet8f	pblend (const Selector< 8 > &ifPacket, const Packet8f &thenPacket, const Packet8f &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet4d	pblend (const Selector< 4 > &ifPacket, const Packet4d &thenPacket, const Packet4d &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet8h	pset1< Packet8h > (const Eigen::half &from)
template<>
EIGEN_STRONG_INLINE Eigen::half	pfirst< Packet8h > (const Packet8h &from)
template<>
EIGEN_STRONG_INLINE Packet8h	pload< Packet8h > (const Eigen::half *from)
template<>
EIGEN_STRONG_INLINE Packet8h	ploadu< Packet8h > (const Eigen::half *from)
template<>
EIGEN_STRONG_INLINE void	pstore< Eigen::half > (Eigen::half *to, const Packet8h &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< Eigen::half > (Eigen::half *to, const Packet8h &from)
template<>
EIGEN_STRONG_INLINE Packet8h	ploaddup< Packet8h > (const Eigen::half *from)
template<>
EIGEN_STRONG_INLINE Packet8h	ploadquad< Packet8h > (const Eigen::half *from)
template<>
EIGEN_STRONG_INLINE Packet8h	ptrue (const Packet8h &a)
template<>
EIGEN_STRONG_INLINE Packet8h	pabs (const Packet8h &a)
EIGEN_STRONG_INLINE Packet8f	half2float (const Packet8h &a)
EIGEN_STRONG_INLINE Packet8h	float2half (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE Packet8h	pmin< Packet8h > (const Packet8h &a, const Packet8h &b)
template<>
EIGEN_STRONG_INLINE Packet8h	pmax< Packet8h > (const Packet8h &a, const Packet8h &b)
template<>
EIGEN_STRONG_INLINE Packet8h	plset< Packet8h > (const half &a)
template<>
EIGEN_STRONG_INLINE Packet8h	por (const Packet8h &a, const Packet8h &b)
template<>
EIGEN_STRONG_INLINE Packet8h	pxor (const Packet8h &a, const Packet8h &b)
template<>
EIGEN_STRONG_INLINE Packet8h	pand (const Packet8h &a, const Packet8h &b)
template<>
EIGEN_STRONG_INLINE Packet8h	pandnot (const Packet8h &a, const Packet8h &b)
template<>
EIGEN_STRONG_INLINE Packet8h	pselect (const Packet8h &mask, const Packet8h &a, const Packet8h &b)
template<>
EIGEN_STRONG_INLINE Packet8h	pround< Packet8h > (const Packet8h &a)
template<>
EIGEN_STRONG_INLINE Packet8h	print< Packet8h > (const Packet8h &a)
template<>
EIGEN_STRONG_INLINE Packet8h	pceil< Packet8h > (const Packet8h &a)
template<>
EIGEN_STRONG_INLINE Packet8h	pfloor< Packet8h > (const Packet8h &a)
template<>
EIGEN_STRONG_INLINE Packet8h	pcmp_eq (const Packet8h &a, const Packet8h &b)
template<>
EIGEN_STRONG_INLINE Packet8h	pcmp_le (const Packet8h &a, const Packet8h &b)
template<>
EIGEN_STRONG_INLINE Packet8h	pcmp_lt (const Packet8h &a, const Packet8h &b)
template<>
EIGEN_STRONG_INLINE Packet8h	pcmp_lt_or_nan (const Packet8h &a, const Packet8h &b)
template<>
EIGEN_STRONG_INLINE Packet8h	pconj (const Packet8h &a)
template<>
EIGEN_STRONG_INLINE Packet8h	pnegate (const Packet8h &a)
template<>
EIGEN_STRONG_INLINE Packet8h	padd< Packet8h > (const Packet8h &a, const Packet8h &b)
template<>
EIGEN_STRONG_INLINE Packet8h	psub< Packet8h > (const Packet8h &a, const Packet8h &b)
template<>
EIGEN_STRONG_INLINE Packet8h	pmul< Packet8h > (const Packet8h &a, const Packet8h &b)
template<>
EIGEN_STRONG_INLINE Packet8h	pdiv< Packet8h > (const Packet8h &a, const Packet8h &b)
template<>
EIGEN_STRONG_INLINE Packet8h	pgather< Eigen::half, Packet8h > (const Eigen::half *from, Index stride)
template<>
EIGEN_STRONG_INLINE void	pscatter< Eigen::half, Packet8h > (Eigen::half *to, const Packet8h &from, Index stride)
template<>
EIGEN_STRONG_INLINE Eigen::half	predux< Packet8h > (const Packet8h &a)
template<>
EIGEN_STRONG_INLINE Eigen::half	predux_max< Packet8h > (const Packet8h &a)
template<>
EIGEN_STRONG_INLINE Eigen::half	predux_min< Packet8h > (const Packet8h &a)
template<>
EIGEN_STRONG_INLINE Eigen::half	predux_mul< Packet8h > (const Packet8h &a)
template<>
EIGEN_STRONG_INLINE Packet8h	preverse (const Packet8h &a)
EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet8h, 8 > &kernel)
EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet8h, 4 > &kernel)
EIGEN_STRONG_INLINE Packet8f	Bf16ToF32 (const Packet8bf &a)
EIGEN_STRONG_INLINE Packet8bf	F32ToBf16 (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	pset1< Packet8bf > (const bfloat16 &from)
template<>
EIGEN_STRONG_INLINE bfloat16	pfirst< Packet8bf > (const Packet8bf &from)
template<>
EIGEN_STRONG_INLINE Packet8bf	pload< Packet8bf > (const bfloat16 *from)
template<>
EIGEN_STRONG_INLINE Packet8bf	ploadu< Packet8bf > (const bfloat16 *from)
template<>
EIGEN_STRONG_INLINE void	pstore< bfloat16 > (bfloat16 *to, const Packet8bf &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< bfloat16 > (bfloat16 *to, const Packet8bf &from)
template<>
EIGEN_STRONG_INLINE Packet8bf	ploaddup< Packet8bf > (const bfloat16 *from)
template<>
EIGEN_STRONG_INLINE Packet8bf	ploadquad< Packet8bf > (const bfloat16 *from)
template<>
EIGEN_STRONG_INLINE Packet8bf	ptrue (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	pabs (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	pmin< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pmax< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	plset< Packet8bf > (const bfloat16 &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	por (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pxor (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pand (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pandnot (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pselect (const Packet8bf &mask, const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pround< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	print< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	pceil< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	pfloor< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	pcmp_eq (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pcmp_le (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pcmp_lt (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pcmp_lt_or_nan (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pconj (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	pnegate (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	padd< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	psub< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pmul< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pdiv< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
template<>
EIGEN_STRONG_INLINE Packet8bf	pgather< bfloat16, Packet8bf > (const bfloat16 *from, Index stride)
template<>
EIGEN_STRONG_INLINE void	pscatter< bfloat16, Packet8bf > (bfloat16 *to, const Packet8bf &from, Index stride)
template<>
EIGEN_STRONG_INLINE bfloat16	predux< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE bfloat16	predux_max< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE bfloat16	predux_min< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE bfloat16	predux_mul< Packet8bf > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	preverse (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8i	pcast< Packet8f, Packet8i > (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE Packet8f	pcast< Packet8i, Packet8f > (const Packet8i &a)
template<>
EIGEN_STRONG_INLINE Packet8i	preinterpret< Packet8i, Packet8f > (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE Packet8f	preinterpret< Packet8f, Packet8i > (const Packet8i &a)
template<>
EIGEN_STRONG_INLINE Packet8f	pcast< Packet8h, Packet8f > (const Packet8h &a)
template<>
EIGEN_STRONG_INLINE Packet8f	pcast< Packet8bf, Packet8f > (const Packet8bf &a)
template<>
EIGEN_STRONG_INLINE Packet8h	pcast< Packet8f, Packet8h > (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	pcast< Packet8f, Packet8bf > (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE Packet8cf	ptrue< Packet8cf > (const Packet8cf &a)
template<>
EIGEN_STRONG_INLINE Packet8cf	padd< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
template<>
EIGEN_STRONG_INLINE Packet8cf	psub< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
template<>
EIGEN_STRONG_INLINE Packet8cf	pnegate (const Packet8cf &a)
template<>
EIGEN_STRONG_INLINE Packet8cf	pconj (const Packet8cf &a)
template<>
EIGEN_STRONG_INLINE Packet8cf	pmul< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
template<>
EIGEN_STRONG_INLINE Packet8cf	pand< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
template<>
EIGEN_STRONG_INLINE Packet8cf	por< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
template<>
EIGEN_STRONG_INLINE Packet8cf	pxor< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
template<>
EIGEN_STRONG_INLINE Packet8cf	pandnot< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
template<>
EIGEN_STRONG_INLINE Packet8cf	pcmp_eq (const Packet8cf &a, const Packet8cf &b)
template<>
EIGEN_STRONG_INLINE Packet8cf	pload< Packet8cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet8cf	ploadu< Packet8cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet8cf	pset1< Packet8cf > (const std::complex< float > &from)
template<>
EIGEN_STRONG_INLINE Packet8cf	ploaddup< Packet8cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet8cf	ploadquad< Packet8cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE void	pstore< std::complex< float > > (std::complex< float > *to, const Packet8cf &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< std::complex< float > > (std::complex< float > *to, const Packet8cf &from)
template<>
EIGEN_DEVICE_FUNC Packet8cf	pgather< std::complex< float >, Packet8cf > (const std::complex< float > *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< std::complex< float >, Packet8cf > (std::complex< float > *to, const Packet8cf &from, Index stride)
template<>
EIGEN_STRONG_INLINE std::complex< float >	pfirst< Packet8cf > (const Packet8cf &a)
template<>
EIGEN_STRONG_INLINE Packet8cf	preverse (const Packet8cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux< Packet8cf > (const Packet8cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux_mul< Packet8cf > (const Packet8cf &a)
template<>
EIGEN_STRONG_INLINE Packet4cf	predux_half_dowto4< Packet8cf > (const Packet8cf &a)
template<>
EIGEN_STRONG_INLINE Packet8cf	pdiv< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
template<>
EIGEN_STRONG_INLINE Packet8cf	pcplxflip< Packet8cf > (const Packet8cf &x)
template<>
EIGEN_STRONG_INLINE Packet4cd	padd< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
template<>
EIGEN_STRONG_INLINE Packet4cd	psub< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
template<>
EIGEN_STRONG_INLINE Packet4cd	pnegate (const Packet4cd &a)
template<>
EIGEN_STRONG_INLINE Packet4cd	pconj (const Packet4cd &a)
template<>
EIGEN_STRONG_INLINE Packet4cd	pmul< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
template<>
EIGEN_STRONG_INLINE Packet4cd	ptrue< Packet4cd > (const Packet4cd &a)
template<>
EIGEN_STRONG_INLINE Packet4cd	pand< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
template<>
EIGEN_STRONG_INLINE Packet4cd	por< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
template<>
EIGEN_STRONG_INLINE Packet4cd	pxor< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
template<>
EIGEN_STRONG_INLINE Packet4cd	pandnot< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
template<>
EIGEN_STRONG_INLINE Packet4cd	pcmp_eq (const Packet4cd &a, const Packet4cd &b)
template<>
EIGEN_STRONG_INLINE Packet4cd	pload< Packet4cd > (const std::complex< double > *from)
template<>
EIGEN_STRONG_INLINE Packet4cd	ploadu< Packet4cd > (const std::complex< double > *from)
template<>
EIGEN_STRONG_INLINE Packet4cd	pset1< Packet4cd > (const std::complex< double > &from)
template<>
EIGEN_STRONG_INLINE Packet4cd	ploaddup< Packet4cd > (const std::complex< double > *from)
template<>
EIGEN_STRONG_INLINE void	pstore< std::complex< double > > (std::complex< double > *to, const Packet4cd &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< std::complex< double > > (std::complex< double > *to, const Packet4cd &from)
template<>
EIGEN_DEVICE_FUNC Packet4cd	pgather< std::complex< double >, Packet4cd > (const std::complex< double > *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< std::complex< double >, Packet4cd > (std::complex< double > *to, const Packet4cd &from, Index stride)
template<>
EIGEN_STRONG_INLINE std::complex< double >	pfirst< Packet4cd > (const Packet4cd &a)
template<>
EIGEN_STRONG_INLINE Packet4cd	preverse (const Packet4cd &a)
template<>
EIGEN_STRONG_INLINE std::complex< double >	predux< Packet4cd > (const Packet4cd &a)
template<>
EIGEN_STRONG_INLINE std::complex< double >	predux_mul< Packet4cd > (const Packet4cd &a)
template<>
EIGEN_STRONG_INLINE Packet4cd	pdiv< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
template<>
EIGEN_STRONG_INLINE Packet4cd	pcplxflip< Packet4cd > (const Packet4cd &x)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet8cf, 4 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet8cf, 8 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet4cd, 4 > &kernel)
template<>
EIGEN_STRONG_INLINE Packet4cd	psqrt< Packet4cd > (const Packet4cd &a)
template<>
EIGEN_STRONG_INLINE Packet8cf	psqrt< Packet8cf > (const Packet8cf &a)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f	psin< Packet16f > (const Packet16f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f	pcos< Packet16f > (const Packet16f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f	ptanh< Packet16f > (const Packet16f &_x)
template<>
EIGEN_STRONG_INLINE Packet16f	pset1< Packet16f > (const float &from)
template<>
EIGEN_STRONG_INLINE Packet8d	pset1< Packet8d > (const double &from)
template<>
EIGEN_STRONG_INLINE Packet16i	pset1< Packet16i > (const int &from)
template<>
EIGEN_STRONG_INLINE Packet16f	pset1frombits< Packet16f > (unsigned int from)
template<>
EIGEN_STRONG_INLINE Packet8d	pset1frombits< Packet8d > (const numext::uint64_t from)
template<>
EIGEN_STRONG_INLINE Packet16f	pzero (const Packet16f &)
template<>
EIGEN_STRONG_INLINE Packet8d	pzero (const Packet8d &)
template<>
EIGEN_STRONG_INLINE Packet16i	pzero (const Packet16i &)
template<>
EIGEN_STRONG_INLINE Packet16f	peven_mask (const Packet16f &)
template<>
EIGEN_STRONG_INLINE Packet16i	peven_mask (const Packet16i &)
template<>
EIGEN_STRONG_INLINE Packet8d	peven_mask (const Packet8d &)
template<>
EIGEN_STRONG_INLINE Packet16f	pload1< Packet16f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet8d	pload1< Packet8d > (const double *from)
template<>
EIGEN_STRONG_INLINE Packet16f	plset< Packet16f > (const float &a)
template<>
EIGEN_STRONG_INLINE Packet8d	plset< Packet8d > (const double &a)
template<>
EIGEN_STRONG_INLINE Packet16f	padd< Packet16f > (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet8d	padd< Packet8d > (const Packet8d &a, const Packet8d &b)
template<>
EIGEN_STRONG_INLINE Packet16i	padd< Packet16i > (const Packet16i &a, const Packet16i &b)
template<>
EIGEN_STRONG_INLINE Packet16f	psub< Packet16f > (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet8d	psub< Packet8d > (const Packet8d &a, const Packet8d &b)
template<>
EIGEN_STRONG_INLINE Packet16i	psub< Packet16i > (const Packet16i &a, const Packet16i &b)
template<>
EIGEN_STRONG_INLINE Packet16f	pnegate (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE Packet8d	pnegate (const Packet8d &a)
template<>
EIGEN_STRONG_INLINE Packet16f	pconj (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE Packet8d	pconj (const Packet8d &a)
template<>
EIGEN_STRONG_INLINE Packet16i	pconj (const Packet16i &a)
template<>
EIGEN_STRONG_INLINE Packet16f	pmul< Packet16f > (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet8d	pmul< Packet8d > (const Packet8d &a, const Packet8d &b)
template<>
EIGEN_STRONG_INLINE Packet16i	pmul< Packet16i > (const Packet16i &a, const Packet16i &b)
template<>
EIGEN_STRONG_INLINE Packet16f	pdiv< Packet16f > (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet8d	pdiv< Packet8d > (const Packet8d &a, const Packet8d &b)
template<>
EIGEN_DEVICE_FUNC Packet16f	pselect (const Packet16f &mask, const Packet16f &a, const Packet16f &b)
template<>
EIGEN_DEVICE_FUNC Packet8d	pselect (const Packet8d &mask, const Packet8d &a, const Packet8d &b)
template<>
EIGEN_STRONG_INLINE Packet16f	pmin< Packet16f > (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet8d	pmin< Packet8d > (const Packet8d &a, const Packet8d &b)
template<>
EIGEN_STRONG_INLINE Packet16f	pmax< Packet16f > (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet8d	pmax< Packet8d > (const Packet8d &a, const Packet8d &b)
template<>
EIGEN_STRONG_INLINE Packet16f	pmin< PropagateNumbers, Packet16f > (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet8d	pmin< PropagateNumbers, Packet8d > (const Packet8d &a, const Packet8d &b)
template<>
EIGEN_STRONG_INLINE Packet16f	pmax< PropagateNumbers, Packet16f > (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet8d	pmax< PropagateNumbers, Packet8d > (const Packet8d &a, const Packet8d &b)
template<>
EIGEN_STRONG_INLINE Packet16f	pmin< PropagateNaN, Packet16f > (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet8d	pmin< PropagateNaN, Packet8d > (const Packet8d &a, const Packet8d &b)
template<>
EIGEN_STRONG_INLINE Packet16f	pmax< PropagateNaN, Packet16f > (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet8d	pmax< PropagateNaN, Packet8d > (const Packet8d &a, const Packet8d &b)
template<int I_>
EIGEN_STRONG_INLINE Packet8f	extract256 (Packet16f x)
template<int I_>
EIGEN_STRONG_INLINE Packet2d	extract128 (Packet8d x)
EIGEN_STRONG_INLINE Packet16f	cat256 (Packet8f a, Packet8f b)
EIGEN_STRONG_INLINE __m256i	Pack32To16 (Packet16f rf)
template<>
EIGEN_STRONG_INLINE Packet16f	pcmp_eq (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet16f	pcmp_le (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet16f	pcmp_lt (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet16f	pcmp_lt_or_nan (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet16i	pcmp_eq (const Packet16i &a, const Packet16i &b)
template<>
EIGEN_STRONG_INLINE Packet8d	pcmp_eq (const Packet8d &a, const Packet8d &b)
template<>
EIGEN_STRONG_INLINE Packet8d	pcmp_le (const Packet8d &a, const Packet8d &b)
template<>
EIGEN_STRONG_INLINE Packet8d	pcmp_lt (const Packet8d &a, const Packet8d &b)
template<>
EIGEN_STRONG_INLINE Packet8d	pcmp_lt_or_nan (const Packet8d &a, const Packet8d &b)
template<>
EIGEN_STRONG_INLINE Packet16f	print< Packet16f > (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE Packet8d	print< Packet8d > (const Packet8d &a)
template<>
EIGEN_STRONG_INLINE Packet16f	pceil< Packet16f > (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE Packet8d	pceil< Packet8d > (const Packet8d &a)
template<>
EIGEN_STRONG_INLINE Packet16f	pfloor< Packet16f > (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE Packet8d	pfloor< Packet8d > (const Packet8d &a)
template<>
EIGEN_STRONG_INLINE Packet16i	ptrue< Packet16i > (const Packet16i &)
template<>
EIGEN_STRONG_INLINE Packet16f	ptrue< Packet16f > (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE Packet8d	ptrue< Packet8d > (const Packet8d &a)
template<>
EIGEN_STRONG_INLINE Packet16i	pand< Packet16i > (const Packet16i &a, const Packet16i &b)
template<>
EIGEN_STRONG_INLINE Packet16f	pand< Packet16f > (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet8d	pand< Packet8d > (const Packet8d &a, const Packet8d &b)
template<>
EIGEN_STRONG_INLINE Packet16i	por< Packet16i > (const Packet16i &a, const Packet16i &b)
template<>
EIGEN_STRONG_INLINE Packet16f	por< Packet16f > (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet8d	por< Packet8d > (const Packet8d &a, const Packet8d &b)
template<>
EIGEN_STRONG_INLINE Packet16i	pxor< Packet16i > (const Packet16i &a, const Packet16i &b)
template<>
EIGEN_STRONG_INLINE Packet16f	pxor< Packet16f > (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet8d	pxor< Packet8d > (const Packet8d &a, const Packet8d &b)
template<>
EIGEN_STRONG_INLINE Packet16i	pandnot< Packet16i > (const Packet16i &a, const Packet16i &b)
template<>
EIGEN_STRONG_INLINE Packet16f	pandnot< Packet16f > (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet8d	pandnot< Packet8d > (const Packet8d &a, const Packet8d &b)
template<>
EIGEN_STRONG_INLINE Packet16f	pround< Packet16f > (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE Packet8d	pround< Packet8d > (const Packet8d &a)
template<int N>
EIGEN_STRONG_INLINE Packet16i	parithmetic_shift_right (Packet16i a)
template<int N>
EIGEN_STRONG_INLINE Packet16i	plogical_shift_right (Packet16i a)
template<int N>
EIGEN_STRONG_INLINE Packet16i	plogical_shift_left (Packet16i a)
template<>
EIGEN_STRONG_INLINE Packet16f	pload< Packet16f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet8d	pload< Packet8d > (const double *from)
template<>
EIGEN_STRONG_INLINE Packet16i	pload< Packet16i > (const int *from)
template<>
EIGEN_STRONG_INLINE Packet16f	ploadu< Packet16f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet8d	ploadu< Packet8d > (const double *from)
template<>
EIGEN_STRONG_INLINE Packet16i	ploadu< Packet16i > (const int *from)
template<>
EIGEN_STRONG_INLINE Packet16f	ploadu< Packet16f > (const float *from, uint16_t umask)
template<>
EIGEN_STRONG_INLINE Packet16f	ploaddup< Packet16f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet8d	ploaddup< Packet8d > (const double *from)
template<>
EIGEN_STRONG_INLINE Packet16f	ploadquad< Packet16f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet8d	ploadquad< Packet8d > (const double *from)
template<>
EIGEN_STRONG_INLINE void	pstore< float > (float *to, const Packet16f &from)
template<>
EIGEN_STRONG_INLINE void	pstore< double > (double *to, const Packet8d &from)
template<>
EIGEN_STRONG_INLINE void	pstore< int > (int *to, const Packet16i &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< float > (float *to, const Packet16f &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< double > (double *to, const Packet8d &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< int > (int *to, const Packet16i &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< float > (float *to, const Packet16f &from, uint16_t umask)
template<>
EIGEN_DEVICE_FUNC Packet16f	pgather< float, Packet16f > (const float *from, Index stride)
template<>
EIGEN_DEVICE_FUNC Packet8d	pgather< double, Packet8d > (const double *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< float, Packet16f > (float *to, const Packet16f &from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< double, Packet8d > (double *to, const Packet8d &from, Index stride)
template<>
EIGEN_STRONG_INLINE void	pstore1< Packet16f > (float *to, const float &a)
template<>
EIGEN_STRONG_INLINE void	pstore1< Packet8d > (double *to, const double &a)
template<>
EIGEN_STRONG_INLINE void	pstore1< Packet16i > (int *to, const int &a)
template<>
EIGEN_STRONG_INLINE void	prefetch< float > (const float *addr)
template<>
EIGEN_STRONG_INLINE void	prefetch< double > (const double *addr)
template<>
EIGEN_STRONG_INLINE void	prefetch< int > (const int *addr)
template<>
EIGEN_STRONG_INLINE float	pfirst< Packet16f > (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE double	pfirst< Packet8d > (const Packet8d &a)
template<>
EIGEN_STRONG_INLINE int	pfirst< Packet16i > (const Packet16i &a)
template<>
EIGEN_STRONG_INLINE Packet16f	preverse (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE Packet8d	preverse (const Packet8d &a)
template<>
EIGEN_STRONG_INLINE Packet16f	pabs (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE Packet8d	pabs (const Packet8d &a)
template<>
EIGEN_STRONG_INLINE Packet16f	pfrexp< Packet16f > (const Packet16f &a, Packet16f &exponent)
template<>
EIGEN_STRONG_INLINE Packet8d	pfrexp_generic_get_biased_exponent (const Packet8d &a)
template<>
EIGEN_STRONG_INLINE Packet8d	pfrexp< Packet8d > (const Packet8d &a, Packet8d &exponent)
template<>
EIGEN_STRONG_INLINE Packet16f	pldexp< Packet16f > (const Packet16f &a, const Packet16f &exponent)
template<>
EIGEN_STRONG_INLINE Packet8d	pldexp< Packet8d > (const Packet8d &a, const Packet8d &exponent)
template<>
EIGEN_STRONG_INLINE float	predux< Packet16f > (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE double	predux< Packet8d > (const Packet8d &a)
template<>
EIGEN_STRONG_INLINE Packet8f	predux_half_dowto4< Packet16f > (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE Packet4d	predux_half_dowto4< Packet8d > (const Packet8d &a)
template<>
EIGEN_STRONG_INLINE float	predux_mul< Packet16f > (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE double	predux_mul< Packet8d > (const Packet8d &a)
template<>
EIGEN_STRONG_INLINE float	predux_min< Packet16f > (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE double	predux_min< Packet8d > (const Packet8d &a)
template<>
EIGEN_STRONG_INLINE float	predux_max< Packet16f > (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE double	predux_max< Packet8d > (const Packet8d &a)
template<>
EIGEN_STRONG_INLINE bool	predux_any (const Packet16f &x)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet16f, 16 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet16f, 4 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet8d, 4 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet8d, 8 > &kernel)
template<>
EIGEN_STRONG_INLINE Packet16f	pblend (const Selector< 16 > &, const Packet16f &, const Packet16f &)
template<>
EIGEN_STRONG_INLINE Packet8d	pblend (const Selector< 8 > &ifPacket, const Packet8d &thenPacket, const Packet8d &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet16h	pset1< Packet16h > (const Eigen::half &from)
template<>
EIGEN_STRONG_INLINE Eigen::half	pfirst< Packet16h > (const Packet16h &from)
template<>
EIGEN_STRONG_INLINE Packet16h	pload< Packet16h > (const Eigen::half *from)
template<>
EIGEN_STRONG_INLINE Packet16h	ploadu< Packet16h > (const Eigen::half *from)
template<>
EIGEN_STRONG_INLINE void	pstore< half > (Eigen::half *to, const Packet16h &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< half > (Eigen::half *to, const Packet16h &from)
template<>
EIGEN_STRONG_INLINE Packet16h	ploaddup< Packet16h > (const Eigen::half *from)
template<>
EIGEN_STRONG_INLINE Packet16h	ploadquad (const Eigen::half *from)
EIGEN_STRONG_INLINE Packet16f	half2float (const Packet16h &a)
EIGEN_STRONG_INLINE Packet16h	float2half (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE Packet16h	ptrue (const Packet16h &a)
template<>
EIGEN_STRONG_INLINE Packet16h	pabs (const Packet16h &a)
template<>
EIGEN_STRONG_INLINE Packet16h	pmin< Packet16h > (const Packet16h &a, const Packet16h &b)
template<>
EIGEN_STRONG_INLINE Packet16h	pmax< Packet16h > (const Packet16h &a, const Packet16h &b)
template<>
EIGEN_STRONG_INLINE Packet16h	plset< Packet16h > (const half &a)
template<>
EIGEN_STRONG_INLINE Packet16h	por (const Packet16h &a, const Packet16h &b)
template<>
EIGEN_STRONG_INLINE Packet16h	pxor (const Packet16h &a, const Packet16h &b)
template<>
EIGEN_STRONG_INLINE Packet16h	pand (const Packet16h &a, const Packet16h &b)
template<>
EIGEN_STRONG_INLINE Packet16h	pandnot (const Packet16h &a, const Packet16h &b)
template<>
EIGEN_STRONG_INLINE Packet16h	pselect (const Packet16h &mask, const Packet16h &a, const Packet16h &b)
template<>
EIGEN_STRONG_INLINE Packet16h	pround< Packet16h > (const Packet16h &a)
template<>
EIGEN_STRONG_INLINE Packet16h	print< Packet16h > (const Packet16h &a)
template<>
EIGEN_STRONG_INLINE Packet16h	pceil< Packet16h > (const Packet16h &a)
template<>
EIGEN_STRONG_INLINE Packet16h	pfloor< Packet16h > (const Packet16h &a)
template<>
EIGEN_STRONG_INLINE Packet16h	pcmp_eq (const Packet16h &a, const Packet16h &b)
template<>
EIGEN_STRONG_INLINE Packet16h	pcmp_le (const Packet16h &a, const Packet16h &b)
template<>
EIGEN_STRONG_INLINE Packet16h	pcmp_lt (const Packet16h &a, const Packet16h &b)
template<>
EIGEN_STRONG_INLINE Packet16h	pcmp_lt_or_nan (const Packet16h &a, const Packet16h &b)
template<>
EIGEN_STRONG_INLINE Packet16h	pconj (const Packet16h &a)
template<>
EIGEN_STRONG_INLINE Packet16h	pnegate (const Packet16h &a)
template<>
EIGEN_STRONG_INLINE Packet16h	padd< Packet16h > (const Packet16h &a, const Packet16h &b)
template<>
EIGEN_STRONG_INLINE Packet16h	psub< Packet16h > (const Packet16h &a, const Packet16h &b)
template<>
EIGEN_STRONG_INLINE Packet16h	pmul< Packet16h > (const Packet16h &a, const Packet16h &b)
template<>
EIGEN_STRONG_INLINE Packet16h	pdiv< Packet16h > (const Packet16h &a, const Packet16h &b)
template<>
EIGEN_STRONG_INLINE half	predux< Packet16h > (const Packet16h &from)
template<>
EIGEN_STRONG_INLINE Packet8h	predux_half_dowto4< Packet16h > (const Packet16h &a)
template<>
EIGEN_STRONG_INLINE Eigen::half	predux_max< Packet16h > (const Packet16h &a)
template<>
EIGEN_STRONG_INLINE Eigen::half	predux_min< Packet16h > (const Packet16h &a)
template<>
EIGEN_STRONG_INLINE half	predux_mul< Packet16h > (const Packet16h &from)
template<>
EIGEN_STRONG_INLINE Packet16h	preverse (const Packet16h &a)
template<>
EIGEN_STRONG_INLINE Packet16h	pgather< Eigen::half, Packet16h > (const Eigen::half *from, Index stride)
template<>
EIGEN_STRONG_INLINE void	pscatter< half, Packet16h > (half *to, const Packet16h &from, Index stride)
EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet16h, 16 > &kernel)
EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet16h, 8 > &kernel)
EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet16h, 4 > &kernel)
template<>
EIGEN_STRONG_INLINE Packet16bf	pset1< Packet16bf > (const bfloat16 &from)
template<>
EIGEN_STRONG_INLINE bfloat16	pfirst< Packet16bf > (const Packet16bf &from)
template<>
EIGEN_STRONG_INLINE Packet16bf	pload< Packet16bf > (const bfloat16 *from)
template<>
EIGEN_STRONG_INLINE Packet16bf	ploadu< Packet16bf > (const bfloat16 *from)
template<>
EIGEN_STRONG_INLINE void	pstore< bfloat16 > (bfloat16 *to, const Packet16bf &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< bfloat16 > (bfloat16 *to, const Packet16bf &from)
template<>
EIGEN_STRONG_INLINE Packet16bf	ploaddup< Packet16bf > (const bfloat16 *from)
template<>
EIGEN_STRONG_INLINE Packet16bf	ploadquad (const bfloat16 *from)
EIGEN_STRONG_INLINE Packet16f	Bf16ToF32 (const Packet16bf &a)
EIGEN_STRONG_INLINE Packet16bf	F32ToBf16 (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE Packet16bf	ptrue (const Packet16bf &a)
template<>
EIGEN_STRONG_INLINE Packet16bf	por (const Packet16bf &a, const Packet16bf &b)
template<>
EIGEN_STRONG_INLINE Packet16bf	pxor (const Packet16bf &a, const Packet16bf &b)
template<>
EIGEN_STRONG_INLINE Packet16bf	pand (const Packet16bf &a, const Packet16bf &b)
template<>
EIGEN_STRONG_INLINE Packet16bf	pandnot (const Packet16bf &a, const Packet16bf &b)
template<>
EIGEN_STRONG_INLINE Packet16bf	pselect (const Packet16bf &mask, const Packet16bf &a, const Packet16bf &b)
template<>
EIGEN_STRONG_INLINE Packet16bf	pround< Packet16bf > (const Packet16bf &a)
template<>
EIGEN_STRONG_INLINE Packet16bf	print< Packet16bf > (const Packet16bf &a)
template<>
EIGEN_STRONG_INLINE Packet16bf	pceil< Packet16bf > (const Packet16bf &a)
template<>
EIGEN_STRONG_INLINE Packet16bf	pfloor< Packet16bf > (const Packet16bf &a)
template<>
EIGEN_STRONG_INLINE Packet16bf	pcmp_eq (const Packet16bf &a, const Packet16bf &b)
template<>
EIGEN_STRONG_INLINE Packet16bf	pcmp_le (const Packet16bf &a, const Packet16bf &b)
template<>
EIGEN_STRONG_INLINE Packet16bf	pcmp_lt (const Packet16bf &a, const Packet16bf &b)
template<>
EIGEN_STRONG_INLINE Packet16bf	pcmp_lt_or_nan (const Packet16bf &a, const Packet16bf &b)
template<>
EIGEN_STRONG_INLINE Packet16bf	pnegate (const Packet16bf &a)
template<>
EIGEN_STRONG_INLINE Packet16bf	pconj (const Packet16bf &a)
template<>
EIGEN_STRONG_INLINE Packet16bf	pabs (const Packet16bf &a)
template<>
EIGEN_STRONG_INLINE Packet16bf	padd< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
template<>
EIGEN_STRONG_INLINE Packet16bf	psub< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
template<>
EIGEN_STRONG_INLINE Packet16bf	pmul< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
template<>
EIGEN_STRONG_INLINE Packet16bf	pdiv< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
template<>
EIGEN_STRONG_INLINE Packet16bf	pmin< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
template<>
EIGEN_STRONG_INLINE Packet16bf	pmax< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
template<>
EIGEN_STRONG_INLINE Packet16bf	plset< Packet16bf > (const bfloat16 &a)
template<>
EIGEN_STRONG_INLINE Packet8bf	predux_half_dowto4< Packet16bf > (const Packet16bf &a)
template<>
EIGEN_STRONG_INLINE bfloat16	predux< Packet16bf > (const Packet16bf &p)
template<>
EIGEN_STRONG_INLINE bfloat16	predux_mul< Packet16bf > (const Packet16bf &from)
template<>
EIGEN_STRONG_INLINE bfloat16	predux_min< Packet16bf > (const Packet16bf &from)
template<>
EIGEN_STRONG_INLINE bfloat16	predux_max< Packet16bf > (const Packet16bf &from)
template<>
EIGEN_STRONG_INLINE Packet16bf	preverse (const Packet16bf &a)
template<>
EIGEN_STRONG_INLINE Packet16bf	pgather< bfloat16, Packet16bf > (const bfloat16 *from, Index stride)
template<>
EIGEN_STRONG_INLINE void	pscatter< bfloat16, Packet16bf > (bfloat16 *to, const Packet16bf &from, Index stride)
EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet16bf, 16 > &kernel)
EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet16bf, 4 > &kernel)
template<>
EIGEN_STRONG_INLINE Packet16i	pcast< Packet16f, Packet16i > (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE Packet16f	pcast< Packet16i, Packet16f > (const Packet16i &a)
template<>
EIGEN_STRONG_INLINE Packet16i	preinterpret< Packet16i, Packet16f > (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE Packet16f	preinterpret< Packet16f, Packet16i > (const Packet16i &a)
template<>
EIGEN_STRONG_INLINE Packet16f	pcast< Packet16h, Packet16f > (const Packet16h &a)
template<>
EIGEN_STRONG_INLINE Packet16h	pcast< Packet16f, Packet16h > (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE Packet16f	pcast< Packet16bf, Packet16f > (const Packet16bf &a)
template<>
EIGEN_STRONG_INLINE Packet16bf	pcast< Packet16f, Packet16bf > (const Packet16f &a)
template<typename Packet >
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet	pfrexp_generic_get_biased_exponent (const Packet &a)
template<typename Packet >
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet	pfrexp_generic (const Packet &a, Packet &exponent)
template<typename Packet >
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet	pldexp_generic (const Packet &a, const Packet &exponent)
template<typename Packet , bool base2>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet	plog_impl_float (const Packet _x)
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet	plog_float (const Packet _x)
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet	plog2_float (const Packet _x)
template<typename Packet , bool base2>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet	plog_impl_double (const Packet _x)
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet	plog_double (const Packet _x)
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet	plog2_double (const Packet _x)
template<typename Packet >
Packet	generic_plog1p (const Packet &x)
template<typename Packet >
Packet	generic_expm1 (const Packet &x)
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet	pexp_float (const Packet _x)
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet	pexp_double (const Packet _x)
float	trig_reduce_huge (float xf, int *quadrant)
template<bool ComputeSine, typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet	psincos_float (const Packet &_x)
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet	psin_float (const Packet &x)
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet	pcos_float (const Packet &x)
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet	psqrt_complex (const Packet &a)
template<typename Packet >
EIGEN_STRONG_INLINE void	absolute_split (const Packet &x, Packet &n, Packet &r)
template<typename Packet >
EIGEN_STRONG_INLINE void	fast_twosum (const Packet &x, const Packet &y, Packet &s_hi, Packet &s_lo)
template<typename Packet >
EIGEN_STRONG_INLINE void	veltkamp_splitting (const Packet &x, Packet &x_hi, Packet &x_lo)
template<typename Packet >
EIGEN_STRONG_INLINE void	twoprod (const Packet &x, const Packet &y, Packet &p_hi, Packet &p_lo)
template<typename Packet >
EIGEN_STRONG_INLINE 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 Packet >
EIGEN_STRONG_INLINE 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 Packet >
EIGEN_STRONG_INLINE void	fast_twosum (const Packet &x, const Packet &y_hi, const Packet &y_lo, Packet &s_hi, Packet &s_lo)
template<typename Packet >
EIGEN_STRONG_INLINE void	twoprod (const Packet &x_hi, const Packet &x_lo, const Packet &y, Packet &p_hi, Packet &p_lo)
template<typename Packet >
EIGEN_STRONG_INLINE void	twoprod (const Packet &x_hi, const Packet &x_lo, const Packet &y_hi, const Packet &y_lo, Packet &p_hi, Packet &p_lo)
template<typename Packet >
void	doubleword_reciprocal (const Packet &x, Packet &recip_hi, Packet &recip_lo)
template<typename Packet >
EIGEN_STRONG_INLINE Packet	generic_pow_impl (const Packet &x, const Packet &y)
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet	generic_pow (const Packet &x, const Packet &y)
std::ostream &	operator<< (std::ostream &os, const Packet2cf &value)
template<>
EIGEN_STRONG_INLINE Packet2cf	pset1< Packet2cf > (const std::complex< float > &from)
template<>
EIGEN_STRONG_INLINE Packet2cf	padd< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	psub< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pnegate (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pconj (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pmul< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pand< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	por< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pxor< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pandnot< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pload< Packet2cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet2cf	ploadu< Packet2cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet2cf	ploaddup< Packet2cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE void	pstore< std::complex< float > > (std::complex< float > *to, const Packet2cf &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< std::complex< float > > (std::complex< float > *to, const Packet2cf &from)
template<>
EIGEN_DEVICE_FUNC Packet2cf	pgather< std::complex< float >, Packet2cf > (const std::complex< float > *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< std::complex< float >, Packet2cf > (std::complex< float > *to, const Packet2cf &from, Index stride)
template<>
EIGEN_STRONG_INLINE void	prefetch< std::complex< float > > (const std::complex< float > *addr)
template<>
EIGEN_STRONG_INLINE std::complex< float >	pfirst< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	preverse (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pcplxflip< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux_mul< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pdiv< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
std::ostream &	operator<< (std::ostream &os, const PacketBlock< Packet2cf, 2 > &value)
template<>
EIGEN_STRONG_INLINE Packet2cf	pblend (const Selector< 2 > &ifPacket, const Packet2cf &thenPacket, const Packet2cf &elsePacket)
std::ostream &	operator<< (std::ostream &os, const Packet1cd &value)
template<>
EIGEN_STRONG_INLINE Packet1cd	pload< Packet1cd > (const std::complex< double > *from)
template<>
EIGEN_STRONG_INLINE Packet1cd	ploadu< Packet1cd > (const std::complex< double > *from)
template<>
EIGEN_STRONG_INLINE Packet1cd	pset1< Packet1cd > (const std::complex< double > &from)
template<>
EIGEN_STRONG_INLINE Packet1cd	padd< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	psub< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pnegate (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	pconj (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	pmul< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pand< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	por< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pxor< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pandnot< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	ploaddup< Packet1cd > (const std::complex< double > *from)
template<>
EIGEN_STRONG_INLINE void	pstore< std::complex< double > > (std::complex< double > *to, const Packet1cd &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< std::complex< double > > (std::complex< double > *to, const Packet1cd &from)
template<>
EIGEN_STRONG_INLINE void	prefetch< std::complex< double > > (const std::complex< double > *addr)
template<>
EIGEN_DEVICE_FUNC Packet1cd	pgather< std::complex< double >, Packet1cd > (const std::complex< double > *from, Index stride __attribute__((unused)))
template<>
EIGEN_DEVICE_FUNC void	pscatter< std::complex< double >, Packet1cd > (std::complex< double > *to, const Packet1cd &from, Index stride __attribute__((unused)))
template<>
EIGEN_STRONG_INLINE std::complex< double >	pfirst< Packet1cd > (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	preverse (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE std::complex< double >	predux< Packet1cd > (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE std::complex< double >	predux_mul< Packet1cd > (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	pdiv< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
EIGEN_STRONG_INLINE Packet1cd	pcplxflip (const Packet1cd &x)
std::ostream &	operator<< (std::ostream &os, const PacketBlock< Packet1cd, 2 > &value)
EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet1cd, 2 > &kernel)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	plog< Packet4f > (const Packet4f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	pexp< Packet4f > (const Packet4f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	ptanh< Packet4f > (const Packet4f &_x)
template<bool sine>
Packet4f	psincos_inner_msa_float (const Packet4f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	psin< Packet4f > (const Packet4f &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	pcos< Packet4f > (const Packet4f &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d	pexp< Packet2d > (const Packet2d &_x)
template<>
EIGEN_STRONG_INLINE Packet4f	pset1< Packet4f > (const float &from)
template<>
EIGEN_STRONG_INLINE Packet4i	pset1< Packet4i > (const int32_t &from)
template<>
EIGEN_STRONG_INLINE Packet4f	pload1< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4i	pload1< Packet4i > (const int32_t *from)
template<>
EIGEN_STRONG_INLINE Packet4f	padd< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	padd< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4f	plset< Packet4f > (const float &a)
template<>
EIGEN_STRONG_INLINE Packet4i	plset< Packet4i > (const int32_t &a)
template<>
EIGEN_STRONG_INLINE Packet4f	psub< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	psub< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pnegate (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pnegate (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pconj (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pconj (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pmul< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pmul< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pdiv< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pdiv< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pmadd (const Packet4f &a, const Packet4f &b, const Packet4f &c)
template<>
EIGEN_STRONG_INLINE Packet4i	pmadd (const Packet4i &a, const Packet4i &b, const Packet4i &c)
template<>
EIGEN_STRONG_INLINE Packet4f	pand< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pand< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4f	por< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	por< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pxor< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pxor< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pandnot< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pandnot< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pmin< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pmin< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pmax< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pmax< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pload< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4i	pload< Packet4i > (const int32_t *from)
template<>
EIGEN_STRONG_INLINE Packet4f	ploadu< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4i	ploadu< Packet4i > (const int32_t *from)
template<>
EIGEN_STRONG_INLINE Packet4f	ploaddup< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4i	ploaddup< Packet4i > (const int32_t *from)
template<>
EIGEN_STRONG_INLINE void	pstore< float > (float *to, const Packet4f &from)
template<>
EIGEN_STRONG_INLINE void	pstore< int32_t > (int32_t *to, const Packet4i &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< float > (float *to, const Packet4f &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< int32_t > (int32_t *to, const Packet4i &from)
template<>
EIGEN_DEVICE_FUNC Packet4f	pgather< float, Packet4f > (const float *from, Index stride)
template<>
EIGEN_DEVICE_FUNC Packet4i	pgather< int32_t, Packet4i > (const int32_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< float, Packet4f > (float *to, const Packet4f &from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< int32_t, Packet4i > (int32_t *to, const Packet4i &from, Index stride)
template<>
EIGEN_STRONG_INLINE void	prefetch< float > (const float *addr)
template<>
EIGEN_STRONG_INLINE void	prefetch< int32_t > (const int32_t *addr)
template<>
EIGEN_STRONG_INLINE float	pfirst< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE int32_t	pfirst< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4f	preverse (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4i	preverse (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pabs (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pabs (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE float	predux< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE int32_t	predux< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE float	predux_mul< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE int32_t	predux_mul< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE float	predux_min< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE int32_t	predux_min< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE float	predux_max< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE int32_t	predux_max< Packet4i > (const Packet4i &a)
std::ostream &	operator<< (std::ostream &os, const PacketBlock< Packet4f, 4 > &value)
std::ostream &	operator<< (std::ostream &os, const PacketBlock< Packet4i, 4 > &value)
template<>
EIGEN_STRONG_INLINE Packet4f	psqrt (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	prsqrt (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pfloor< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pceil< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pround< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pblend (const Selector< 4 > &ifPacket, const Packet4f &thenPacket, const Packet4f &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet4i	pblend (const Selector< 4 > &ifPacket, const Packet4i &thenPacket, const Packet4i &elsePacket)
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)
template<>
EIGEN_STRONG_INLINE Packet2d	pset1< Packet2d > (const double &from)
template<>
EIGEN_STRONG_INLINE Packet2d	padd< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet2d	plset< Packet2d > (const double &a)
template<>
EIGEN_STRONG_INLINE Packet2d	psub< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pnegate (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pconj (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pmul< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pdiv< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pmadd (const Packet2d &a, const Packet2d &b, const Packet2d &c)
template<>
EIGEN_STRONG_INLINE Packet2d	pand< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet2d	por< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pxor< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pandnot< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pload< Packet2d > (const double *from)
template<>
EIGEN_STRONG_INLINE Packet2d	pmin< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pmax< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet2d	ploadu< Packet2d > (const double *from)
template<>
EIGEN_STRONG_INLINE Packet2d	ploaddup< Packet2d > (const double *from)
template<>
EIGEN_STRONG_INLINE void	pstore< double > (double *to, const Packet2d &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< double > (double *to, const Packet2d &from)
template<>
EIGEN_DEVICE_FUNC Packet2d	pgather< double, Packet2d > (const double *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< double, Packet2d > (double *to, const Packet2d &from, Index stride)
template<>
EIGEN_STRONG_INLINE void	prefetch< double > (const double *addr)
template<>
EIGEN_STRONG_INLINE double	pfirst< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet2d	preverse (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pabs (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE double	predux< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE double	predux_mul< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE double	predux_min< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE double	predux_max< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet2d	psqrt (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet2d	prsqrt (const Packet2d &a)
std::ostream &	operator<< (std::ostream &os, const PacketBlock< Packet2d, 2 > &value)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet2d, 2 > &kernel)
template<>
EIGEN_STRONG_INLINE Packet2d	pfloor< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pceil< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pround< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pblend (const Selector< 2 > &ifPacket, const Packet2d &thenPacket, const Packet2d &elsePacket)
uint32x2_t	p2ui_CONJ_XOR ()
template<>
EIGEN_STRONG_INLINE Packet1cf	pcast< float, Packet1cf > (const float &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pcast< Packet2f, Packet2cf > (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE Packet1cf	pset1< Packet1cf > (const std::complex< float > &from)
template<>
EIGEN_STRONG_INLINE Packet2cf	pset1< Packet2cf > (const std::complex< float > &from)
template<>
EIGEN_STRONG_INLINE Packet1cf	padd< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	padd< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet1cf	psub< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	psub< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet1cf	pnegate (const Packet1cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pnegate (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet1cf	pconj (const Packet1cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pconj (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet1cf	pmul< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pmul< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet1cf	pcmp_eq (const Packet1cf &a, const Packet1cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pcmp_eq (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet1cf	pand< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pand< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet1cf	por< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	por< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet1cf	pxor< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pxor< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet1cf	pandnot< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pandnot< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet1cf	pload< Packet1cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet2cf	pload< Packet2cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet1cf	ploadu< Packet1cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet2cf	ploadu< Packet2cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet1cf	ploaddup< Packet1cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet2cf	ploaddup< Packet2cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE void	pstore< std::complex< float > > (std::complex< float > *to, const Packet1cf &from)
template<>
EIGEN_STRONG_INLINE void	pstore< std::complex< float > > (std::complex< float > *to, const Packet2cf &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< std::complex< float > > (std::complex< float > *to, const Packet1cf &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< std::complex< float > > (std::complex< float > *to, const Packet2cf &from)
template<>
EIGEN_DEVICE_FUNC Packet1cf	pgather< std::complex< float >, Packet1cf > (const std::complex< float > *from, Index stride)
template<>
EIGEN_DEVICE_FUNC Packet2cf	pgather< std::complex< float >, Packet2cf > (const std::complex< float > *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< std::complex< float >, Packet1cf > (std::complex< float > *to, const Packet1cf &from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< std::complex< float >, Packet2cf > (std::complex< float > *to, const Packet2cf &from, Index stride)
template<>
EIGEN_STRONG_INLINE void	prefetch< std::complex< float > > (const std::complex< float > *addr)
template<>
EIGEN_STRONG_INLINE std::complex< float >	pfirst< Packet1cf > (const Packet1cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	pfirst< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet1cf	preverse (const Packet1cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	preverse (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet1cf	pcplxflip< Packet1cf > (const Packet1cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pcplxflip< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux< Packet1cf > (const Packet1cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux_mul< Packet1cf > (const Packet1cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux_mul< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet1cf	pdiv< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pdiv< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet1cf, 1 > &)
template<>
EIGEN_STRONG_INLINE Packet1cf	psqrt< Packet1cf > (const Packet1cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	psqrt< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f	pexp< Packet2f > (const Packet2f &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	pexp< Packet4f > (const Packet4f &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f	plog< Packet2f > (const Packet2f &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	plog< Packet4f > (const Packet4f &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f	psin< Packet2f > (const Packet2f &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	psin< Packet4f > (const Packet4f &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f	pcos< Packet2f > (const Packet2f &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	pcos< Packet4f > (const Packet4f &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f	ptanh< Packet2f > (const Packet2f &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	ptanh< Packet4f > (const Packet4f &x)
template<>
EIGEN_STRONG_INLINE Packet4bf	pfrexp (const Packet4bf &a, Packet4bf &exponent)
template<>
EIGEN_STRONG_INLINE Packet4bf	pldexp (const Packet4bf &a, const Packet4bf &exponent)
EIGEN_STRONG_INLINE Packet4f	shuffle1 (const Packet4f &m, int mask)
template<bool interleave>
EIGEN_STRONG_INLINE Packet4f	shuffle2 (const Packet4f &m, const Packet4f &n, int mask)
template<>
EIGEN_STRONG_INLINE Packet4f	shuffle2< true > (const Packet4f &m, const Packet4f &n, int mask)
EIGEN_STRONG_INLINE Packet4f	vec4f_swizzle1 (const Packet4f &a, int p, int q, int r, int s)
EIGEN_STRONG_INLINE Packet4f	vec4f_swizzle2 (const Packet4f &a, const Packet4f &b, int p, int q, int r, int s)
EIGEN_STRONG_INLINE Packet4f	vec4f_movelh (const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet4f	vec4f_movehl (const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet4f	vec4f_unpacklo (const Packet4f &a, const Packet4f &b)
EIGEN_STRONG_INLINE Packet4f	vec4f_unpackhi (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2f	pset1< Packet2f > (const float &from)
template<>
EIGEN_STRONG_INLINE Packet4f	pset1< Packet4f > (const float &from)
template<>
EIGEN_STRONG_INLINE Packet4c	pset1< Packet4c > (const int8_t &from)
template<>
EIGEN_STRONG_INLINE Packet8c	pset1< Packet8c > (const int8_t &from)
template<>
EIGEN_STRONG_INLINE Packet16c	pset1< Packet16c > (const int8_t &from)
template<>
EIGEN_STRONG_INLINE Packet4uc	pset1< Packet4uc > (const uint8_t &from)
template<>
EIGEN_STRONG_INLINE Packet8uc	pset1< Packet8uc > (const uint8_t &from)
template<>
EIGEN_STRONG_INLINE Packet16uc	pset1< Packet16uc > (const uint8_t &from)
template<>
EIGEN_STRONG_INLINE Packet4s	pset1< Packet4s > (const int16_t &from)
template<>
EIGEN_STRONG_INLINE Packet8s	pset1< Packet8s > (const int16_t &from)
template<>
EIGEN_STRONG_INLINE Packet4us	pset1< Packet4us > (const uint16_t &from)
template<>
EIGEN_STRONG_INLINE Packet8us	pset1< Packet8us > (const uint16_t &from)
template<>
EIGEN_STRONG_INLINE Packet2i	pset1< Packet2i > (const int32_t &from)
template<>
EIGEN_STRONG_INLINE Packet4i	pset1< Packet4i > (const int32_t &from)
template<>
EIGEN_STRONG_INLINE Packet2ui	pset1< Packet2ui > (const uint32_t &from)
template<>
EIGEN_STRONG_INLINE Packet4ui	pset1< Packet4ui > (const uint32_t &from)
template<>
EIGEN_STRONG_INLINE Packet2l	pset1< Packet2l > (const int64_t &from)
template<>
EIGEN_STRONG_INLINE Packet2ul	pset1< Packet2ul > (const uint64_t &from)
template<>
EIGEN_STRONG_INLINE Packet2f	pset1frombits< Packet2f > (unsigned int from)
template<>
EIGEN_STRONG_INLINE Packet4f	pset1frombits< Packet4f > (unsigned int from)
template<>
EIGEN_STRONG_INLINE Packet2f	plset< Packet2f > (const float &a)
template<>
EIGEN_STRONG_INLINE Packet4f	plset< Packet4f > (const float &a)
template<>
EIGEN_STRONG_INLINE Packet4c	plset< Packet4c > (const int8_t &a)
template<>
EIGEN_STRONG_INLINE Packet8c	plset< Packet8c > (const int8_t &a)
template<>
EIGEN_STRONG_INLINE Packet16c	plset< Packet16c > (const int8_t &a)
template<>
EIGEN_STRONG_INLINE Packet4uc	plset< Packet4uc > (const uint8_t &a)
template<>
EIGEN_STRONG_INLINE Packet8uc	plset< Packet8uc > (const uint8_t &a)
template<>
EIGEN_STRONG_INLINE Packet16uc	plset< Packet16uc > (const uint8_t &a)
template<>
EIGEN_STRONG_INLINE Packet4s	plset< Packet4s > (const int16_t &a)
template<>
EIGEN_STRONG_INLINE Packet4us	plset< Packet4us > (const uint16_t &a)
template<>
EIGEN_STRONG_INLINE Packet8s	plset< Packet8s > (const int16_t &a)
template<>
EIGEN_STRONG_INLINE Packet8us	plset< Packet8us > (const uint16_t &a)
template<>
EIGEN_STRONG_INLINE Packet2i	plset< Packet2i > (const int32_t &a)
template<>
EIGEN_STRONG_INLINE Packet4i	plset< Packet4i > (const int32_t &a)
template<>
EIGEN_STRONG_INLINE Packet2ui	plset< Packet2ui > (const uint32_t &a)
template<>
EIGEN_STRONG_INLINE Packet4ui	plset< Packet4ui > (const uint32_t &a)
template<>
EIGEN_STRONG_INLINE Packet2l	plset< Packet2l > (const int64_t &a)
template<>
EIGEN_STRONG_INLINE Packet2ul	plset< Packet2ul > (const uint64_t &a)
template<>
EIGEN_STRONG_INLINE Packet2f	padd< Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	padd< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4c	padd< Packet4c > (const Packet4c &a, const Packet4c &b)
template<>
EIGEN_STRONG_INLINE Packet8c	padd< Packet8c > (const Packet8c &a, const Packet8c &b)
template<>
EIGEN_STRONG_INLINE Packet16c	padd< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet4uc	padd< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
template<>
EIGEN_STRONG_INLINE Packet8uc	padd< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	padd< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4s	padd< Packet4s > (const Packet4s &a, const Packet4s &b)
template<>
EIGEN_STRONG_INLINE Packet8s	padd< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet4us	padd< Packet4us > (const Packet4us &a, const Packet4us &b)
template<>
EIGEN_STRONG_INLINE Packet8us	padd< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet2i	padd< Packet2i > (const Packet2i &a, const Packet2i &b)
template<>
EIGEN_STRONG_INLINE Packet4i	padd< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2ui	padd< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
template<>
EIGEN_STRONG_INLINE Packet4ui	padd< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_STRONG_INLINE Packet2l	padd< Packet2l > (const Packet2l &a, const Packet2l &b)
template<>
EIGEN_STRONG_INLINE Packet2ul	padd< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
template<>
EIGEN_STRONG_INLINE Packet2f	psub< Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	psub< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4c	psub< Packet4c > (const Packet4c &a, const Packet4c &b)
template<>
EIGEN_STRONG_INLINE Packet8c	psub< Packet8c > (const Packet8c &a, const Packet8c &b)
template<>
EIGEN_STRONG_INLINE Packet16c	psub< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet4uc	psub< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
template<>
EIGEN_STRONG_INLINE Packet8uc	psub< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	psub< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4s	psub< Packet4s > (const Packet4s &a, const Packet4s &b)
template<>
EIGEN_STRONG_INLINE Packet8s	psub< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet4us	psub< Packet4us > (const Packet4us &a, const Packet4us &b)
template<>
EIGEN_STRONG_INLINE Packet8us	psub< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet2i	psub< Packet2i > (const Packet2i &a, const Packet2i &b)
template<>
EIGEN_STRONG_INLINE Packet4i	psub< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2ui	psub< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
template<>
EIGEN_STRONG_INLINE Packet4ui	psub< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_STRONG_INLINE Packet2l	psub< Packet2l > (const Packet2l &a, const Packet2l &b)
template<>
EIGEN_STRONG_INLINE Packet2ul	psub< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
template<>
EIGEN_STRONG_INLINE Packet2f	pxor< Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet2f	paddsub< Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pxor< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	paddsub< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2f	pnegate (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pnegate (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4c	pnegate (const Packet4c &a)
template<>
EIGEN_STRONG_INLINE Packet8c	pnegate (const Packet8c &a)
template<>
EIGEN_STRONG_INLINE Packet16c	pnegate (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE Packet4s	pnegate (const Packet4s &a)
template<>
EIGEN_STRONG_INLINE Packet8s	pnegate (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE Packet2i	pnegate (const Packet2i &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pnegate (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet2l	pnegate (const Packet2l &a)
template<>
EIGEN_STRONG_INLINE Packet2f	pconj (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pconj (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4c	pconj (const Packet4c &a)
template<>
EIGEN_STRONG_INLINE Packet8c	pconj (const Packet8c &a)
template<>
EIGEN_STRONG_INLINE Packet16c	pconj (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE Packet4uc	pconj (const Packet4uc &a)
template<>
EIGEN_STRONG_INLINE Packet8uc	pconj (const Packet8uc &a)
template<>
EIGEN_STRONG_INLINE Packet16uc	pconj (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE Packet4s	pconj (const Packet4s &a)
template<>
EIGEN_STRONG_INLINE Packet8s	pconj (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE Packet4us	pconj (const Packet4us &a)
template<>
EIGEN_STRONG_INLINE Packet8us	pconj (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE Packet2i	pconj (const Packet2i &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pconj (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet2ui	pconj (const Packet2ui &a)
template<>
EIGEN_STRONG_INLINE Packet4ui	pconj (const Packet4ui &a)
template<>
EIGEN_STRONG_INLINE Packet2l	pconj (const Packet2l &a)
template<>
EIGEN_STRONG_INLINE Packet2ul	pconj (const Packet2ul &a)
template<>
EIGEN_STRONG_INLINE Packet2f	pmul< Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pmul< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4c	pmul< Packet4c > (const Packet4c &a, const Packet4c &b)
template<>
EIGEN_STRONG_INLINE Packet8c	pmul< Packet8c > (const Packet8c &a, const Packet8c &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pmul< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet4uc	pmul< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
template<>
EIGEN_STRONG_INLINE Packet8uc	pmul< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pmul< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4s	pmul< Packet4s > (const Packet4s &a, const Packet4s &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pmul< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet4us	pmul< Packet4us > (const Packet4us &a, const Packet4us &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pmul< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet2i	pmul< Packet2i > (const Packet2i &a, const Packet2i &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pmul< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2ui	pmul< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
template<>
EIGEN_STRONG_INLINE Packet4ui	pmul< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_STRONG_INLINE Packet2l	pmul< Packet2l > (const Packet2l &a, const Packet2l &b)
template<>
EIGEN_STRONG_INLINE Packet2ul	pmul< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
template<>
EIGEN_STRONG_INLINE Packet2f	pdiv< Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pdiv< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4c	pdiv< Packet4c > (const Packet4c &, const Packet4c &)
template<>
EIGEN_STRONG_INLINE Packet8c	pdiv< Packet8c > (const Packet8c &, const Packet8c &)
template<>
EIGEN_STRONG_INLINE Packet16c	pdiv< Packet16c > (const Packet16c &, const Packet16c &)
template<>
EIGEN_STRONG_INLINE Packet4uc	pdiv< Packet4uc > (const Packet4uc &, const Packet4uc &)
template<>
EIGEN_STRONG_INLINE Packet8uc	pdiv< Packet8uc > (const Packet8uc &, const Packet8uc &)
template<>
EIGEN_STRONG_INLINE Packet16uc	pdiv< Packet16uc > (const Packet16uc &, const Packet16uc &)
template<>
EIGEN_STRONG_INLINE Packet4s	pdiv< Packet4s > (const Packet4s &, const Packet4s &)
template<>
EIGEN_STRONG_INLINE Packet8s	pdiv< Packet8s > (const Packet8s &, const Packet8s &)
template<>
EIGEN_STRONG_INLINE Packet4us	pdiv< Packet4us > (const Packet4us &, const Packet4us &)
template<>
EIGEN_STRONG_INLINE Packet8us	pdiv< Packet8us > (const Packet8us &, const Packet8us &)
template<>
EIGEN_STRONG_INLINE Packet2i	pdiv< Packet2i > (const Packet2i &, const Packet2i &)
template<>
EIGEN_STRONG_INLINE Packet4i	pdiv< Packet4i > (const Packet4i &, const Packet4i &)
template<>
EIGEN_STRONG_INLINE Packet2ui	pdiv< Packet2ui > (const Packet2ui &, const Packet2ui &)
template<>
EIGEN_STRONG_INLINE Packet4ui	pdiv< Packet4ui > (const Packet4ui &, const Packet4ui &)
template<>
EIGEN_STRONG_INLINE Packet2l	pdiv< Packet2l > (const Packet2l &, const Packet2l &)
template<>
EIGEN_STRONG_INLINE Packet2ul	pdiv< Packet2ul > (const Packet2ul &, const Packet2ul &)
template<>
EIGEN_STRONG_INLINE Packet4f	pmadd (const Packet4f &a, const Packet4f &b, const Packet4f &c)
template<>
EIGEN_STRONG_INLINE Packet2f	pmadd (const Packet2f &a, const Packet2f &b, const Packet2f &c)
template<>
EIGEN_STRONG_INLINE Packet4c	pmadd (const Packet4c &a, const Packet4c &b, const Packet4c &c)
template<>
EIGEN_STRONG_INLINE Packet8c	pmadd (const Packet8c &a, const Packet8c &b, const Packet8c &c)
template<>
EIGEN_STRONG_INLINE Packet16c	pmadd (const Packet16c &a, const Packet16c &b, const Packet16c &c)
template<>
EIGEN_STRONG_INLINE Packet4uc	pmadd (const Packet4uc &a, const Packet4uc &b, const Packet4uc &c)
template<>
EIGEN_STRONG_INLINE Packet8uc	pmadd (const Packet8uc &a, const Packet8uc &b, const Packet8uc &c)
template<>
EIGEN_STRONG_INLINE Packet16uc	pmadd (const Packet16uc &a, const Packet16uc &b, const Packet16uc &c)
template<>
EIGEN_STRONG_INLINE Packet4s	pmadd (const Packet4s &a, const Packet4s &b, const Packet4s &c)
template<>
EIGEN_STRONG_INLINE Packet8s	pmadd (const Packet8s &a, const Packet8s &b, const Packet8s &c)
template<>
EIGEN_STRONG_INLINE Packet4us	pmadd (const Packet4us &a, const Packet4us &b, const Packet4us &c)
template<>
EIGEN_STRONG_INLINE Packet8us	pmadd (const Packet8us &a, const Packet8us &b, const Packet8us &c)
template<>
EIGEN_STRONG_INLINE Packet2i	pmadd (const Packet2i &a, const Packet2i &b, const Packet2i &c)
template<>
EIGEN_STRONG_INLINE Packet4i	pmadd (const Packet4i &a, const Packet4i &b, const Packet4i &c)
template<>
EIGEN_STRONG_INLINE Packet2ui	pmadd (const Packet2ui &a, const Packet2ui &b, const Packet2ui &c)
template<>
EIGEN_STRONG_INLINE Packet4ui	pmadd (const Packet4ui &a, const Packet4ui &b, const Packet4ui &c)
template<>
EIGEN_STRONG_INLINE Packet2f	pabsdiff< Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pabsdiff< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4c	pabsdiff< Packet4c > (const Packet4c &a, const Packet4c &b)
template<>
EIGEN_STRONG_INLINE Packet8c	pabsdiff< Packet8c > (const Packet8c &a, const Packet8c &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pabsdiff< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet4uc	pabsdiff< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
template<>
EIGEN_STRONG_INLINE Packet8uc	pabsdiff< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pabsdiff< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4s	pabsdiff< Packet4s > (const Packet4s &a, const Packet4s &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pabsdiff< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet4us	pabsdiff< Packet4us > (const Packet4us &a, const Packet4us &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pabsdiff< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet2i	pabsdiff< Packet2i > (const Packet2i &a, const Packet2i &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pabsdiff< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2ui	pabsdiff< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
template<>
EIGEN_STRONG_INLINE Packet4ui	pabsdiff< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_STRONG_INLINE Packet2f	pmin< Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pmin< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pmin< PropagateNaN, Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2f	pmin< PropagateNaN, Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4c	pmin< Packet4c > (const Packet4c &a, const Packet4c &b)
template<>
EIGEN_STRONG_INLINE Packet8c	pmin< Packet8c > (const Packet8c &a, const Packet8c &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pmin< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet4uc	pmin< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
template<>
EIGEN_STRONG_INLINE Packet8uc	pmin< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pmin< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4s	pmin< Packet4s > (const Packet4s &a, const Packet4s &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pmin< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet4us	pmin< Packet4us > (const Packet4us &a, const Packet4us &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pmin< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet2i	pmin< Packet2i > (const Packet2i &a, const Packet2i &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pmin< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2ui	pmin< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
template<>
EIGEN_STRONG_INLINE Packet4ui	pmin< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_STRONG_INLINE Packet2l	pmin< Packet2l > (const Packet2l &a, const Packet2l &b)
template<>
EIGEN_STRONG_INLINE Packet2ul	pmin< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
template<>
EIGEN_STRONG_INLINE Packet2f	pmax< Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pmax< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pmax< PropagateNaN, Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2f	pmax< PropagateNaN, Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4c	pmax< Packet4c > (const Packet4c &a, const Packet4c &b)
template<>
EIGEN_STRONG_INLINE Packet8c	pmax< Packet8c > (const Packet8c &a, const Packet8c &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pmax< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet4uc	pmax< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
template<>
EIGEN_STRONG_INLINE Packet8uc	pmax< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pmax< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4s	pmax< Packet4s > (const Packet4s &a, const Packet4s &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pmax< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet4us	pmax< Packet4us > (const Packet4us &a, const Packet4us &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pmax< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet2i	pmax< Packet2i > (const Packet2i &a, const Packet2i &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pmax< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2ui	pmax< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
template<>
EIGEN_STRONG_INLINE Packet4ui	pmax< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_STRONG_INLINE Packet2l	pmax< Packet2l > (const Packet2l &a, const Packet2l &b)
template<>
EIGEN_STRONG_INLINE Packet2ul	pmax< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
template<>
EIGEN_STRONG_INLINE Packet2f	pcmp_le< Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pcmp_le< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4c	pcmp_le< Packet4c > (const Packet4c &a, const Packet4c &b)
template<>
EIGEN_STRONG_INLINE Packet8c	pcmp_le< Packet8c > (const Packet8c &a, const Packet8c &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pcmp_le< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet4uc	pcmp_le< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
template<>
EIGEN_STRONG_INLINE Packet8uc	pcmp_le< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pcmp_le< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4s	pcmp_le< Packet4s > (const Packet4s &a, const Packet4s &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pcmp_le< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet4us	pcmp_le< Packet4us > (const Packet4us &a, const Packet4us &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pcmp_le< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet2i	pcmp_le< Packet2i > (const Packet2i &a, const Packet2i &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pcmp_le< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2ui	pcmp_le< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
template<>
EIGEN_STRONG_INLINE Packet4ui	pcmp_le< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_STRONG_INLINE Packet2l	pcmp_le< Packet2l > (const Packet2l &a, const Packet2l &b)
template<>
EIGEN_STRONG_INLINE Packet2ul	pcmp_le< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
template<>
EIGEN_STRONG_INLINE Packet2f	pcmp_lt< Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pcmp_lt< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4c	pcmp_lt< Packet4c > (const Packet4c &a, const Packet4c &b)
template<>
EIGEN_STRONG_INLINE Packet8c	pcmp_lt< Packet8c > (const Packet8c &a, const Packet8c &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pcmp_lt< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet4uc	pcmp_lt< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
template<>
EIGEN_STRONG_INLINE Packet8uc	pcmp_lt< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pcmp_lt< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4s	pcmp_lt< Packet4s > (const Packet4s &a, const Packet4s &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pcmp_lt< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet4us	pcmp_lt< Packet4us > (const Packet4us &a, const Packet4us &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pcmp_lt< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet2i	pcmp_lt< Packet2i > (const Packet2i &a, const Packet2i &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pcmp_lt< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2ui	pcmp_lt< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
template<>
EIGEN_STRONG_INLINE Packet4ui	pcmp_lt< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_STRONG_INLINE Packet2l	pcmp_lt< Packet2l > (const Packet2l &a, const Packet2l &b)
template<>
EIGEN_STRONG_INLINE Packet2ul	pcmp_lt< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
template<>
EIGEN_STRONG_INLINE Packet2f	pcmp_eq< Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pcmp_eq< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4c	pcmp_eq< Packet4c > (const Packet4c &a, const Packet4c &b)
template<>
EIGEN_STRONG_INLINE Packet8c	pcmp_eq< Packet8c > (const Packet8c &a, const Packet8c &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pcmp_eq< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet4uc	pcmp_eq< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
template<>
EIGEN_STRONG_INLINE Packet8uc	pcmp_eq< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pcmp_eq< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4s	pcmp_eq< Packet4s > (const Packet4s &a, const Packet4s &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pcmp_eq< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet4us	pcmp_eq< Packet4us > (const Packet4us &a, const Packet4us &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pcmp_eq< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet2i	pcmp_eq< Packet2i > (const Packet2i &a, const Packet2i &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pcmp_eq< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2ui	pcmp_eq< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
template<>
EIGEN_STRONG_INLINE Packet4ui	pcmp_eq< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_STRONG_INLINE Packet2l	pcmp_eq< Packet2l > (const Packet2l &a, const Packet2l &b)
template<>
EIGEN_STRONG_INLINE Packet2ul	pcmp_eq< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
template<>
EIGEN_STRONG_INLINE Packet2f	pcmp_lt_or_nan< Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pcmp_lt_or_nan< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2f	pand< Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pand< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4c	pand< Packet4c > (const Packet4c &a, const Packet4c &b)
template<>
EIGEN_STRONG_INLINE Packet8c	pand< Packet8c > (const Packet8c &a, const Packet8c &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pand< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet4uc	pand< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
template<>
EIGEN_STRONG_INLINE Packet8uc	pand< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pand< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4s	pand< Packet4s > (const Packet4s &a, const Packet4s &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pand< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet4us	pand< Packet4us > (const Packet4us &a, const Packet4us &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pand< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet2i	pand< Packet2i > (const Packet2i &a, const Packet2i &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pand< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2ui	pand< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
template<>
EIGEN_STRONG_INLINE Packet4ui	pand< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_STRONG_INLINE Packet2l	pand< Packet2l > (const Packet2l &a, const Packet2l &b)
template<>
EIGEN_STRONG_INLINE Packet2ul	pand< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
template<>
EIGEN_STRONG_INLINE Packet2f	por< Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	por< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4c	por< Packet4c > (const Packet4c &a, const Packet4c &b)
template<>
EIGEN_STRONG_INLINE Packet8c	por< Packet8c > (const Packet8c &a, const Packet8c &b)
template<>
EIGEN_STRONG_INLINE Packet16c	por< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet4uc	por< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
template<>
EIGEN_STRONG_INLINE Packet8uc	por< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	por< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4s	por< Packet4s > (const Packet4s &a, const Packet4s &b)
template<>
EIGEN_STRONG_INLINE Packet8s	por< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet4us	por< Packet4us > (const Packet4us &a, const Packet4us &b)
template<>
EIGEN_STRONG_INLINE Packet8us	por< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet2i	por< Packet2i > (const Packet2i &a, const Packet2i &b)
template<>
EIGEN_STRONG_INLINE Packet4i	por< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2ui	por< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
template<>
EIGEN_STRONG_INLINE Packet4ui	por< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_STRONG_INLINE Packet2l	por< Packet2l > (const Packet2l &a, const Packet2l &b)
template<>
EIGEN_STRONG_INLINE Packet2ul	por< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
template<>
EIGEN_STRONG_INLINE Packet2f	pxor< Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pxor< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4c	pxor< Packet4c > (const Packet4c &a, const Packet4c &b)
template<>
EIGEN_STRONG_INLINE Packet8c	pxor< Packet8c > (const Packet8c &a, const Packet8c &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pxor< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet4uc	pxor< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
template<>
EIGEN_STRONG_INLINE Packet8uc	pxor< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pxor< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4s	pxor< Packet4s > (const Packet4s &a, const Packet4s &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pxor< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet4us	pxor< Packet4us > (const Packet4us &a, const Packet4us &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pxor< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet2i	pxor< Packet2i > (const Packet2i &a, const Packet2i &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pxor< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2ui	pxor< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
template<>
EIGEN_STRONG_INLINE Packet4ui	pxor< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_STRONG_INLINE Packet2l	pxor< Packet2l > (const Packet2l &a, const Packet2l &b)
template<>
EIGEN_STRONG_INLINE Packet2ul	pxor< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
template<>
EIGEN_STRONG_INLINE Packet2f	pandnot< Packet2f > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pandnot< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4c	pandnot< Packet4c > (const Packet4c &a, const Packet4c &b)
template<>
EIGEN_STRONG_INLINE Packet8c	pandnot< Packet8c > (const Packet8c &a, const Packet8c &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pandnot< Packet16c > (const Packet16c &a, const Packet16c &b)
template<>
EIGEN_STRONG_INLINE Packet4uc	pandnot< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
template<>
EIGEN_STRONG_INLINE Packet8uc	pandnot< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pandnot< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_STRONG_INLINE Packet4s	pandnot< Packet4s > (const Packet4s &a, const Packet4s &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pandnot< Packet8s > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet4us	pandnot< Packet4us > (const Packet4us &a, const Packet4us &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pandnot< Packet8us > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet2i	pandnot< Packet2i > (const Packet2i &a, const Packet2i &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pandnot< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2ui	pandnot< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
template<>
EIGEN_STRONG_INLINE Packet4ui	pandnot< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_STRONG_INLINE Packet2l	pandnot< Packet2l > (const Packet2l &a, const Packet2l &b)
template<>
EIGEN_STRONG_INLINE Packet2ul	pandnot< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
template<int N>
EIGEN_STRONG_INLINE Packet4c	parithmetic_shift_right (Packet4c &a)
template<int N>
EIGEN_STRONG_INLINE Packet8c	parithmetic_shift_right (Packet8c a)
template<int N>
EIGEN_STRONG_INLINE Packet16c	parithmetic_shift_right (Packet16c a)
template<int N>
EIGEN_STRONG_INLINE Packet4uc	parithmetic_shift_right (Packet4uc &a)
template<int N>
EIGEN_STRONG_INLINE Packet8uc	parithmetic_shift_right (Packet8uc a)
template<int N>
EIGEN_STRONG_INLINE Packet16uc	parithmetic_shift_right (Packet16uc a)
template<int N>
EIGEN_STRONG_INLINE Packet4s	parithmetic_shift_right (Packet4s a)
template<int N>
EIGEN_STRONG_INLINE Packet8s	parithmetic_shift_right (Packet8s a)
template<int N>
EIGEN_STRONG_INLINE Packet4us	parithmetic_shift_right (Packet4us a)
template<int N>
EIGEN_STRONG_INLINE Packet8us	parithmetic_shift_right (Packet8us a)
template<int N>
EIGEN_STRONG_INLINE Packet2i	parithmetic_shift_right (Packet2i a)
template<int N>
EIGEN_STRONG_INLINE Packet4i	parithmetic_shift_right (Packet4i a)
template<int N>
EIGEN_STRONG_INLINE Packet2ui	parithmetic_shift_right (Packet2ui a)
template<int N>
EIGEN_STRONG_INLINE Packet4ui	parithmetic_shift_right (Packet4ui a)
template<int N>
EIGEN_STRONG_INLINE Packet2l	parithmetic_shift_right (Packet2l a)
template<int N>
EIGEN_STRONG_INLINE Packet2ul	parithmetic_shift_right (Packet2ul a)
template<int N>
EIGEN_STRONG_INLINE Packet4c	plogical_shift_right (Packet4c &a)
template<int N>
EIGEN_STRONG_INLINE Packet8c	plogical_shift_right (Packet8c a)
template<int N>
EIGEN_STRONG_INLINE Packet16c	plogical_shift_right (Packet16c a)
template<int N>
EIGEN_STRONG_INLINE Packet4uc	plogical_shift_right (Packet4uc &a)
template<int N>
EIGEN_STRONG_INLINE Packet8uc	plogical_shift_right (Packet8uc a)
template<int N>
EIGEN_STRONG_INLINE Packet16uc	plogical_shift_right (Packet16uc a)
template<int N>
EIGEN_STRONG_INLINE Packet4s	plogical_shift_right (Packet4s a)
template<int N>
EIGEN_STRONG_INLINE Packet8s	plogical_shift_right (Packet8s a)
template<int N>
EIGEN_STRONG_INLINE Packet4us	plogical_shift_right (Packet4us a)
template<int N>
EIGEN_STRONG_INLINE Packet8us	plogical_shift_right (Packet8us a)
template<int N>
EIGEN_STRONG_INLINE Packet2i	plogical_shift_right (Packet2i a)
template<int N>
EIGEN_STRONG_INLINE Packet4i	plogical_shift_right (Packet4i a)
template<int N>
EIGEN_STRONG_INLINE Packet2ui	plogical_shift_right (Packet2ui a)
template<int N>
EIGEN_STRONG_INLINE Packet4ui	plogical_shift_right (Packet4ui a)
template<int N>
EIGEN_STRONG_INLINE Packet2l	plogical_shift_right (Packet2l a)
template<int N>
EIGEN_STRONG_INLINE Packet2ul	plogical_shift_right (Packet2ul a)
template<int N>
EIGEN_STRONG_INLINE Packet4c	plogical_shift_left (Packet4c &a)
template<int N>
EIGEN_STRONG_INLINE Packet8c	plogical_shift_left (Packet8c a)
template<int N>
EIGEN_STRONG_INLINE Packet16c	plogical_shift_left (Packet16c a)
template<int N>
EIGEN_STRONG_INLINE Packet4uc	plogical_shift_left (Packet4uc &a)
template<int N>
EIGEN_STRONG_INLINE Packet8uc	plogical_shift_left (Packet8uc a)
template<int N>
EIGEN_STRONG_INLINE Packet16uc	plogical_shift_left (Packet16uc a)
template<int N>
EIGEN_STRONG_INLINE Packet4s	plogical_shift_left (Packet4s a)
template<int N>
EIGEN_STRONG_INLINE Packet8s	plogical_shift_left (Packet8s a)
template<int N>
EIGEN_STRONG_INLINE Packet4us	plogical_shift_left (Packet4us a)
template<int N>
EIGEN_STRONG_INLINE Packet8us	plogical_shift_left (Packet8us a)
template<int N>
EIGEN_STRONG_INLINE Packet2i	plogical_shift_left (Packet2i a)
template<int N>
EIGEN_STRONG_INLINE Packet4i	plogical_shift_left (Packet4i a)
template<int N>
EIGEN_STRONG_INLINE Packet2ui	plogical_shift_left (Packet2ui a)
template<int N>
EIGEN_STRONG_INLINE Packet4ui	plogical_shift_left (Packet4ui a)
template<int N>
EIGEN_STRONG_INLINE Packet2l	plogical_shift_left (Packet2l a)
template<int N>
EIGEN_STRONG_INLINE Packet2ul	plogical_shift_left (Packet2ul a)
template<>
EIGEN_STRONG_INLINE Packet2f	pload< Packet2f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4f	pload< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4c	pload< Packet4c > (const int8_t *from)
template<>
EIGEN_STRONG_INLINE Packet8c	pload< Packet8c > (const int8_t *from)
template<>
EIGEN_STRONG_INLINE Packet16c	pload< Packet16c > (const int8_t *from)
template<>
EIGEN_STRONG_INLINE Packet4uc	pload< Packet4uc > (const uint8_t *from)
template<>
EIGEN_STRONG_INLINE Packet8uc	pload< Packet8uc > (const uint8_t *from)
template<>
EIGEN_STRONG_INLINE Packet16uc	pload< Packet16uc > (const uint8_t *from)
template<>
EIGEN_STRONG_INLINE Packet4s	pload< Packet4s > (const int16_t *from)
template<>
EIGEN_STRONG_INLINE Packet8s	pload< Packet8s > (const int16_t *from)
template<>
EIGEN_STRONG_INLINE Packet4us	pload< Packet4us > (const uint16_t *from)
template<>
EIGEN_STRONG_INLINE Packet8us	pload< Packet8us > (const uint16_t *from)
template<>
EIGEN_STRONG_INLINE Packet2i	pload< Packet2i > (const int32_t *from)
template<>
EIGEN_STRONG_INLINE Packet4i	pload< Packet4i > (const int32_t *from)
template<>
EIGEN_STRONG_INLINE Packet2ui	pload< Packet2ui > (const uint32_t *from)
template<>
EIGEN_STRONG_INLINE Packet4ui	pload< Packet4ui > (const uint32_t *from)
template<>
EIGEN_STRONG_INLINE Packet2l	pload< Packet2l > (const int64_t *from)
template<>
EIGEN_STRONG_INLINE Packet2ul	pload< Packet2ul > (const uint64_t *from)
template<>
EIGEN_STRONG_INLINE Packet2f	ploadu< Packet2f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4f	ploadu< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4c	ploadu< Packet4c > (const int8_t *from)
template<>
EIGEN_STRONG_INLINE Packet8c	ploadu< Packet8c > (const int8_t *from)
template<>
EIGEN_STRONG_INLINE Packet16c	ploadu< Packet16c > (const int8_t *from)
template<>
EIGEN_STRONG_INLINE Packet4uc	ploadu< Packet4uc > (const uint8_t *from)
template<>
EIGEN_STRONG_INLINE Packet8uc	ploadu< Packet8uc > (const uint8_t *from)
template<>
EIGEN_STRONG_INLINE Packet16uc	ploadu< Packet16uc > (const uint8_t *from)
template<>
EIGEN_STRONG_INLINE Packet4s	ploadu< Packet4s > (const int16_t *from)
template<>
EIGEN_STRONG_INLINE Packet8s	ploadu< Packet8s > (const int16_t *from)
template<>
EIGEN_STRONG_INLINE Packet4us	ploadu< Packet4us > (const uint16_t *from)
template<>
EIGEN_STRONG_INLINE Packet8us	ploadu< Packet8us > (const uint16_t *from)
template<>
EIGEN_STRONG_INLINE Packet2i	ploadu< Packet2i > (const int32_t *from)
template<>
EIGEN_STRONG_INLINE Packet4i	ploadu< Packet4i > (const int32_t *from)
template<>
EIGEN_STRONG_INLINE Packet2ui	ploadu< Packet2ui > (const uint32_t *from)
template<>
EIGEN_STRONG_INLINE Packet4ui	ploadu< Packet4ui > (const uint32_t *from)
template<>
EIGEN_STRONG_INLINE Packet2l	ploadu< Packet2l > (const int64_t *from)
template<>
EIGEN_STRONG_INLINE Packet2ul	ploadu< Packet2ul > (const uint64_t *from)
template<>
EIGEN_STRONG_INLINE Packet2f	ploaddup< Packet2f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4f	ploaddup< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4c	ploaddup< Packet4c > (const int8_t *from)
template<>
EIGEN_STRONG_INLINE Packet8c	ploaddup< Packet8c > (const int8_t *from)
template<>
EIGEN_STRONG_INLINE Packet16c	ploaddup< Packet16c > (const int8_t *from)
template<>
EIGEN_STRONG_INLINE Packet4uc	ploaddup< Packet4uc > (const uint8_t *from)
template<>
EIGEN_STRONG_INLINE Packet8uc	ploaddup< Packet8uc > (const uint8_t *from)
template<>
EIGEN_STRONG_INLINE Packet16uc	ploaddup< Packet16uc > (const uint8_t *from)
template<>
EIGEN_STRONG_INLINE Packet4s	ploaddup< Packet4s > (const int16_t *from)
template<>
EIGEN_STRONG_INLINE Packet8s	ploaddup< Packet8s > (const int16_t *from)
template<>
EIGEN_STRONG_INLINE Packet4us	ploaddup< Packet4us > (const uint16_t *from)
template<>
EIGEN_STRONG_INLINE Packet8us	ploaddup< Packet8us > (const uint16_t *from)
template<>
EIGEN_STRONG_INLINE Packet2i	ploaddup< Packet2i > (const int32_t *from)
template<>
EIGEN_STRONG_INLINE Packet4i	ploaddup< Packet4i > (const int32_t *from)
template<>
EIGEN_STRONG_INLINE Packet2ui	ploaddup< Packet2ui > (const uint32_t *from)
template<>
EIGEN_STRONG_INLINE Packet4ui	ploaddup< Packet4ui > (const uint32_t *from)
template<>
EIGEN_STRONG_INLINE Packet2l	ploaddup< Packet2l > (const int64_t *from)
template<>
EIGEN_STRONG_INLINE Packet2ul	ploaddup< Packet2ul > (const uint64_t *from)
template<>
EIGEN_STRONG_INLINE Packet4f	ploadquad< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4c	ploadquad< Packet4c > (const int8_t *from)
template<>
EIGEN_STRONG_INLINE Packet8c	ploadquad< Packet8c > (const int8_t *from)
template<>
EIGEN_STRONG_INLINE Packet16c	ploadquad< Packet16c > (const int8_t *from)
template<>
EIGEN_STRONG_INLINE Packet4uc	ploadquad< Packet4uc > (const uint8_t *from)
template<>
EIGEN_STRONG_INLINE Packet8uc	ploadquad< Packet8uc > (const uint8_t *from)
template<>
EIGEN_STRONG_INLINE Packet16uc	ploadquad< Packet16uc > (const uint8_t *from)
template<>
EIGEN_STRONG_INLINE Packet8s	ploadquad< Packet8s > (const int16_t *from)
template<>
EIGEN_STRONG_INLINE Packet8us	ploadquad< Packet8us > (const uint16_t *from)
template<>
EIGEN_STRONG_INLINE Packet4i	ploadquad< Packet4i > (const int32_t *from)
template<>
EIGEN_STRONG_INLINE Packet4ui	ploadquad< Packet4ui > (const uint32_t *from)
template<>
EIGEN_STRONG_INLINE void	pstore< float > (float *to, const Packet2f &from)
template<>
EIGEN_STRONG_INLINE void	pstore< float > (float *to, const Packet4f &from)
template<>
EIGEN_STRONG_INLINE void	pstore< int8_t > (int8_t *to, const Packet4c &from)
template<>
EIGEN_STRONG_INLINE void	pstore< int8_t > (int8_t *to, const Packet8c &from)
template<>
EIGEN_STRONG_INLINE void	pstore< int8_t > (int8_t *to, const Packet16c &from)
template<>
EIGEN_STRONG_INLINE void	pstore< uint8_t > (uint8_t *to, const Packet4uc &from)
template<>
EIGEN_STRONG_INLINE void	pstore< uint8_t > (uint8_t *to, const Packet8uc &from)
template<>
EIGEN_STRONG_INLINE void	pstore< uint8_t > (uint8_t *to, const Packet16uc &from)
template<>
EIGEN_STRONG_INLINE void	pstore< int16_t > (int16_t *to, const Packet4s &from)
template<>
EIGEN_STRONG_INLINE void	pstore< int16_t > (int16_t *to, const Packet8s &from)
template<>
EIGEN_STRONG_INLINE void	pstore< uint16_t > (uint16_t *to, const Packet4us &from)
template<>
EIGEN_STRONG_INLINE void	pstore< uint16_t > (uint16_t *to, const Packet8us &from)
template<>
EIGEN_STRONG_INLINE void	pstore< int32_t > (int32_t *to, const Packet2i &from)
template<>
EIGEN_STRONG_INLINE void	pstore< int32_t > (int32_t *to, const Packet4i &from)
template<>
EIGEN_STRONG_INLINE void	pstore< uint32_t > (uint32_t *to, const Packet2ui &from)
template<>
EIGEN_STRONG_INLINE void	pstore< uint32_t > (uint32_t *to, const Packet4ui &from)
template<>
EIGEN_STRONG_INLINE void	pstore< int64_t > (int64_t *to, const Packet2l &from)
template<>
EIGEN_STRONG_INLINE void	pstore< uint64_t > (uint64_t *to, const Packet2ul &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< float > (float *to, const Packet2f &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< float > (float *to, const Packet4f &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< int8_t > (int8_t *to, const Packet4c &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< int8_t > (int8_t *to, const Packet8c &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< int8_t > (int8_t *to, const Packet16c &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< uint8_t > (uint8_t *to, const Packet4uc &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< uint8_t > (uint8_t *to, const Packet8uc &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< uint8_t > (uint8_t *to, const Packet16uc &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< int16_t > (int16_t *to, const Packet4s &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< int16_t > (int16_t *to, const Packet8s &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< uint16_t > (uint16_t *to, const Packet4us &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< uint16_t > (uint16_t *to, const Packet8us &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< int32_t > (int32_t *to, const Packet2i &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< int32_t > (int32_t *to, const Packet4i &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< uint32_t > (uint32_t *to, const Packet2ui &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< uint32_t > (uint32_t *to, const Packet4ui &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< int64_t > (int64_t *to, const Packet2l &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< uint64_t > (uint64_t *to, const Packet2ul &from)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2f	pgather< float, Packet2f > (const float *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4f	pgather< float, Packet4f > (const float *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4c	pgather< int8_t, Packet4c > (const int8_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c	pgather< int8_t, Packet8c > (const int8_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16c	pgather< int8_t, Packet16c > (const int8_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4uc	pgather< uint8_t, Packet4uc > (const uint8_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc	pgather< uint8_t, Packet8uc > (const uint8_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16uc	pgather< uint8_t, Packet16uc > (const uint8_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s	pgather< int16_t, Packet4s > (const int16_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8s	pgather< int16_t, Packet8s > (const int16_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us	pgather< uint16_t, Packet4us > (const uint16_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8us	pgather< uint16_t, Packet8us > (const uint16_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2i	pgather< int32_t, Packet2i > (const int32_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4i	pgather< int32_t, Packet4i > (const int32_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ui	pgather< uint32_t, Packet2ui > (const uint32_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4ui	pgather< uint32_t, Packet4ui > (const uint32_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2l	pgather< int64_t, Packet2l > (const int64_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ul	pgather< uint64_t, Packet2ul > (const uint64_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< float, Packet2f > (float *to, const Packet2f &from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< float, Packet4f > (float *to, const Packet4f &from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< int8_t, Packet4c > (int8_t *to, const Packet4c &from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< int8_t, Packet8c > (int8_t *to, const Packet8c &from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< int8_t, Packet16c > (int8_t *to, const Packet16c &from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< uint8_t, Packet4uc > (uint8_t *to, const Packet4uc &from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< uint8_t, Packet8uc > (uint8_t *to, const Packet8uc &from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< uint8_t, Packet16uc > (uint8_t *to, const Packet16uc &from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< int16_t, Packet4s > (int16_t *to, const Packet4s &from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< int16_t, Packet8s > (int16_t *to, const Packet8s &from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< uint16_t, Packet4us > (uint16_t *to, const Packet4us &from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< uint16_t, Packet8us > (uint16_t *to, const Packet8us &from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< int32_t, Packet2i > (int32_t *to, const Packet2i &from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< int32_t, Packet4i > (int32_t *to, const Packet4i &from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< uint32_t, Packet2ui > (uint32_t *to, const Packet2ui &from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< uint32_t, Packet4ui > (uint32_t *to, const Packet4ui &from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< int64_t, Packet2l > (int64_t *to, const Packet2l &from, Index stride)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	pscatter< uint64_t, Packet2ul > (uint64_t *to, const Packet2ul &from, Index stride)
template<>
EIGEN_STRONG_INLINE void	prefetch< float > (const float *addr)
template<>
EIGEN_STRONG_INLINE void	prefetch< int8_t > (const int8_t *addr)
template<>
EIGEN_STRONG_INLINE void	prefetch< uint8_t > (const uint8_t *addr)
template<>
EIGEN_STRONG_INLINE void	prefetch< int16_t > (const int16_t *addr)
template<>
EIGEN_STRONG_INLINE void	prefetch< uint16_t > (const uint16_t *addr)
template<>
EIGEN_STRONG_INLINE void	prefetch< int32_t > (const int32_t *addr)
template<>
EIGEN_STRONG_INLINE void	prefetch< uint32_t > (const uint32_t *addr)
template<>
EIGEN_STRONG_INLINE void	prefetch< int64_t > (const int64_t *addr)
template<>
EIGEN_STRONG_INLINE void	prefetch< uint64_t > (const uint64_t *addr)
template<>
EIGEN_STRONG_INLINE float	pfirst< Packet2f > (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE float	pfirst< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE int8_t	pfirst< Packet4c > (const Packet4c &a)
template<>
EIGEN_STRONG_INLINE int8_t	pfirst< Packet8c > (const Packet8c &a)
template<>
EIGEN_STRONG_INLINE int8_t	pfirst< Packet16c > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE uint8_t	pfirst< Packet4uc > (const Packet4uc &a)
template<>
EIGEN_STRONG_INLINE uint8_t	pfirst< Packet8uc > (const Packet8uc &a)
template<>
EIGEN_STRONG_INLINE uint8_t	pfirst< Packet16uc > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE int16_t	pfirst< Packet4s > (const Packet4s &a)
template<>
EIGEN_STRONG_INLINE int16_t	pfirst< Packet8s > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE uint16_t	pfirst< Packet4us > (const Packet4us &a)
template<>
EIGEN_STRONG_INLINE uint16_t	pfirst< Packet8us > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE int32_t	pfirst< Packet2i > (const Packet2i &a)
template<>
EIGEN_STRONG_INLINE int32_t	pfirst< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE uint32_t	pfirst< Packet2ui > (const Packet2ui &a)
template<>
EIGEN_STRONG_INLINE uint32_t	pfirst< Packet4ui > (const Packet4ui &a)
template<>
EIGEN_STRONG_INLINE int64_t	pfirst< Packet2l > (const Packet2l &a)
template<>
EIGEN_STRONG_INLINE uint64_t	pfirst< Packet2ul > (const Packet2ul &a)
template<>
EIGEN_STRONG_INLINE Packet2f	preverse (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	preverse (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4c	preverse (const Packet4c &a)
template<>
EIGEN_STRONG_INLINE Packet8c	preverse (const Packet8c &a)
template<>
EIGEN_STRONG_INLINE Packet16c	preverse (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE Packet4uc	preverse (const Packet4uc &a)
template<>
EIGEN_STRONG_INLINE Packet8uc	preverse (const Packet8uc &a)
template<>
EIGEN_STRONG_INLINE Packet16uc	preverse (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE Packet4s	preverse (const Packet4s &a)
template<>
EIGEN_STRONG_INLINE Packet8s	preverse (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE Packet4us	preverse (const Packet4us &a)
template<>
EIGEN_STRONG_INLINE Packet8us	preverse (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE Packet2i	preverse (const Packet2i &a)
template<>
EIGEN_STRONG_INLINE Packet4i	preverse (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet2ui	preverse (const Packet2ui &a)
template<>
EIGEN_STRONG_INLINE Packet4ui	preverse (const Packet4ui &a)
template<>
EIGEN_STRONG_INLINE Packet2l	preverse (const Packet2l &a)
template<>
EIGEN_STRONG_INLINE Packet2ul	preverse (const Packet2ul &a)
template<>
EIGEN_STRONG_INLINE Packet2f	pabs (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pabs (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4c	pabs< Packet4c > (const Packet4c &a)
template<>
EIGEN_STRONG_INLINE Packet8c	pabs (const Packet8c &a)
template<>
EIGEN_STRONG_INLINE Packet16c	pabs (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE Packet4uc	pabs (const Packet4uc &a)
template<>
EIGEN_STRONG_INLINE Packet8uc	pabs (const Packet8uc &a)
template<>
EIGEN_STRONG_INLINE Packet16uc	pabs (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE Packet4s	pabs (const Packet4s &a)
template<>
EIGEN_STRONG_INLINE Packet8s	pabs (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE Packet4us	pabs (const Packet4us &a)
template<>
EIGEN_STRONG_INLINE Packet8us	pabs (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE Packet2i	pabs (const Packet2i &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pabs (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet2ui	pabs (const Packet2ui &a)
template<>
EIGEN_STRONG_INLINE Packet4ui	pabs (const Packet4ui &a)
template<>
EIGEN_STRONG_INLINE Packet2l	pabs (const Packet2l &a)
template<>
EIGEN_STRONG_INLINE Packet2ul	pabs (const Packet2ul &a)
template<>
EIGEN_STRONG_INLINE Packet2f	pfrexp< Packet2f > (const Packet2f &a, Packet2f &exponent)
template<>
EIGEN_STRONG_INLINE Packet4f	pfrexp< Packet4f > (const Packet4f &a, Packet4f &exponent)
template<>
EIGEN_STRONG_INLINE Packet2f	pldexp< Packet2f > (const Packet2f &a, const Packet2f &exponent)
template<>
EIGEN_STRONG_INLINE Packet4f	pldexp< Packet4f > (const Packet4f &a, const Packet4f &exponent)
template<>
EIGEN_STRONG_INLINE float	predux< Packet2f > (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE float	predux< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE int8_t	predux< Packet4c > (const Packet4c &a)
template<>
EIGEN_STRONG_INLINE int8_t	predux< Packet8c > (const Packet8c &a)
template<>
EIGEN_STRONG_INLINE int8_t	predux< Packet16c > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE uint8_t	predux< Packet4uc > (const Packet4uc &a)
template<>
EIGEN_STRONG_INLINE uint8_t	predux< Packet8uc > (const Packet8uc &a)
template<>
EIGEN_STRONG_INLINE uint8_t	predux< Packet16uc > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE int16_t	predux< Packet4s > (const Packet4s &a)
template<>
EIGEN_STRONG_INLINE int16_t	predux< Packet8s > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE uint16_t	predux< Packet4us > (const Packet4us &a)
template<>
EIGEN_STRONG_INLINE uint16_t	predux< Packet8us > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE int32_t	predux< Packet2i > (const Packet2i &a)
template<>
EIGEN_STRONG_INLINE int32_t	predux< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE uint32_t	predux< Packet2ui > (const Packet2ui &a)
template<>
EIGEN_STRONG_INLINE uint32_t	predux< Packet4ui > (const Packet4ui &a)
template<>
EIGEN_STRONG_INLINE int64_t	predux< Packet2l > (const Packet2l &a)
template<>
EIGEN_STRONG_INLINE uint64_t	predux< Packet2ul > (const Packet2ul &a)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4c	predux_half_dowto4 (const Packet8c &a)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c	predux_half_dowto4 (const Packet16c &a)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4uc	predux_half_dowto4 (const Packet8uc &a)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc	predux_half_dowto4 (const Packet16uc &a)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s	predux_half_dowto4 (const Packet8s &a)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us	predux_half_dowto4 (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE float	predux_mul< Packet2f > (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE float	predux_mul< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE int8_t	predux_mul< Packet4c > (const Packet4c &a)
template<>
EIGEN_STRONG_INLINE int8_t	predux_mul< Packet8c > (const Packet8c &a)
template<>
EIGEN_STRONG_INLINE int8_t	predux_mul< Packet16c > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE uint8_t	predux_mul< Packet4uc > (const Packet4uc &a)
template<>
EIGEN_STRONG_INLINE uint8_t	predux_mul< Packet8uc > (const Packet8uc &a)
template<>
EIGEN_STRONG_INLINE uint8_t	predux_mul< Packet16uc > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE int16_t	predux_mul< Packet4s > (const Packet4s &a)
template<>
EIGEN_STRONG_INLINE int16_t	predux_mul< Packet8s > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE uint16_t	predux_mul< Packet4us > (const Packet4us &a)
template<>
EIGEN_STRONG_INLINE uint16_t	predux_mul< Packet8us > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE int32_t	predux_mul< Packet2i > (const Packet2i &a)
template<>
EIGEN_STRONG_INLINE int32_t	predux_mul< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE uint32_t	predux_mul< Packet2ui > (const Packet2ui &a)
template<>
EIGEN_STRONG_INLINE uint32_t	predux_mul< Packet4ui > (const Packet4ui &a)
template<>
EIGEN_STRONG_INLINE int64_t	predux_mul< Packet2l > (const Packet2l &a)
template<>
EIGEN_STRONG_INLINE uint64_t	predux_mul< Packet2ul > (const Packet2ul &a)
template<>
EIGEN_STRONG_INLINE float	predux_min< Packet2f > (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE float	predux_min< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE int8_t	predux_min< Packet4c > (const Packet4c &a)
template<>
EIGEN_STRONG_INLINE int8_t	predux_min< Packet8c > (const Packet8c &a)
template<>
EIGEN_STRONG_INLINE int8_t	predux_min< Packet16c > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE uint8_t	predux_min< Packet4uc > (const Packet4uc &a)
template<>
EIGEN_STRONG_INLINE uint8_t	predux_min< Packet8uc > (const Packet8uc &a)
template<>
EIGEN_STRONG_INLINE uint8_t	predux_min< Packet16uc > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE int16_t	predux_min< Packet4s > (const Packet4s &a)
template<>
EIGEN_STRONG_INLINE int16_t	predux_min< Packet8s > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE uint16_t	predux_min< Packet4us > (const Packet4us &a)
template<>
EIGEN_STRONG_INLINE uint16_t	predux_min< Packet8us > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE int32_t	predux_min< Packet2i > (const Packet2i &a)
template<>
EIGEN_STRONG_INLINE int32_t	predux_min< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE uint32_t	predux_min< Packet2ui > (const Packet2ui &a)
template<>
EIGEN_STRONG_INLINE uint32_t	predux_min< Packet4ui > (const Packet4ui &a)
template<>
EIGEN_STRONG_INLINE int64_t	predux_min< Packet2l > (const Packet2l &a)
template<>
EIGEN_STRONG_INLINE uint64_t	predux_min< Packet2ul > (const Packet2ul &a)
template<>
EIGEN_STRONG_INLINE float	predux_max< Packet2f > (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE float	predux_max< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE int8_t	predux_max< Packet4c > (const Packet4c &a)
template<>
EIGEN_STRONG_INLINE int8_t	predux_max< Packet8c > (const Packet8c &a)
template<>
EIGEN_STRONG_INLINE int8_t	predux_max< Packet16c > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE uint8_t	predux_max< Packet4uc > (const Packet4uc &a)
template<>
EIGEN_STRONG_INLINE uint8_t	predux_max< Packet8uc > (const Packet8uc &a)
template<>
EIGEN_STRONG_INLINE uint8_t	predux_max< Packet16uc > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE int16_t	predux_max< Packet4s > (const Packet4s &a)
template<>
EIGEN_STRONG_INLINE int16_t	predux_max< Packet8s > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE uint16_t	predux_max< Packet4us > (const Packet4us &a)
template<>
EIGEN_STRONG_INLINE uint16_t	predux_max< Packet8us > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE int32_t	predux_max< Packet2i > (const Packet2i &a)
template<>
EIGEN_STRONG_INLINE int32_t	predux_max< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE uint32_t	predux_max< Packet2ui > (const Packet2ui &a)
template<>
EIGEN_STRONG_INLINE uint32_t	predux_max< Packet4ui > (const Packet4ui &a)
template<>
EIGEN_STRONG_INLINE int64_t	predux_max< Packet2l > (const Packet2l &a)
template<>
EIGEN_STRONG_INLINE uint64_t	predux_max< Packet2ul > (const Packet2ul &a)
template<>
EIGEN_STRONG_INLINE bool	predux_any (const Packet4f &x)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet2f, 2 > &kernel)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet4c, 4 > &kernel)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet8c, 8 > &kernel)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet8c, 4 > &kernel)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet16c, 8 > &kernel)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet4uc, 4 > &kernel)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet8uc, 8 > &kernel)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet8uc, 4 > &kernel)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet16uc, 8 > &kernel)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet4s, 4 > &kernel)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet4us, 4 > &kernel)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet2i, 2 > &kernel)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet2ui, 2 > &kernel)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet4ui, 4 > &kernel)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet2l, 2 > &kernel)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet2ul, 2 > &kernel)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2f	pselect (const Packet2f &mask, const Packet2f &a, const Packet2f &b)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4f	pselect (const Packet4f &mask, const Packet4f &a, const Packet4f &b)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c	pselect (const Packet8c &mask, const Packet8c &a, const Packet8c &b)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16c	pselect (const Packet16c &mask, const Packet16c &a, const Packet16c &b)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc	pselect (const Packet8uc &mask, const Packet8uc &a, const Packet8uc &b)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16uc	pselect (const Packet16uc &mask, const Packet16uc &a, const Packet16uc &b)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s	pselect (const Packet4s &mask, const Packet4s &a, const Packet4s &b)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8s	pselect (const Packet8s &mask, const Packet8s &a, const Packet8s &b)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us	pselect (const Packet4us &mask, const Packet4us &a, const Packet4us &b)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8us	pselect (const Packet8us &mask, const Packet8us &a, const Packet8us &b)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2i	pselect (const Packet2i &mask, const Packet2i &a, const Packet2i &b)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4i	pselect (const Packet4i &mask, const Packet4i &a, const Packet4i &b)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ui	pselect (const Packet2ui &mask, const Packet2ui &a, const Packet2ui &b)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4ui	pselect (const Packet4ui &mask, const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2l	pselect (const Packet2l &mask, const Packet2l &a, const Packet2l &b)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ul	pselect (const Packet2ul &mask, const Packet2ul &a, const Packet2ul &b)
template<>
EIGEN_STRONG_INLINE Packet4f	print (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2f	print (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pfloor< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2f	pfloor< Packet2f > (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pceil< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2f	pceil< Packet2f > (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE Packet4uc	psqrt (const Packet4uc &a)
template<>
EIGEN_STRONG_INLINE Packet8uc	psqrt (const Packet8uc &a)
template<>
EIGEN_STRONG_INLINE Packet16uc	psqrt (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE Packet4us	psqrt (const Packet4us &a)
template<>
EIGEN_STRONG_INLINE Packet8us	psqrt (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE Packet2ui	psqrt (const Packet2ui &a)
template<>
EIGEN_STRONG_INLINE Packet4ui	psqrt (const Packet4ui &a)
template<>
EIGEN_STRONG_INLINE Packet4f	prsqrt (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2f	prsqrt (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	psqrt (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2f	psqrt (const Packet2f &a)
EIGEN_STRONG_INLINE Packet4bf	F32ToBf16 (const Packet4f &p)
EIGEN_STRONG_INLINE Packet4f	Bf16ToF32 (const Packet4bf &p)
EIGEN_STRONG_INLINE Packet4bf	F32MaskToBf16Mask (const Packet4f &p)
template<>
EIGEN_STRONG_INLINE Packet4bf	pset1< Packet4bf > (const bfloat16 &from)
template<>
EIGEN_STRONG_INLINE bfloat16	pfirst< Packet4bf > (const Packet4bf &from)
template<>
EIGEN_STRONG_INLINE Packet4bf	pload< Packet4bf > (const bfloat16 *from)
template<>
EIGEN_STRONG_INLINE Packet4bf	ploadu< Packet4bf > (const bfloat16 *from)
template<>
EIGEN_STRONG_INLINE void	pstore< bfloat16 > (bfloat16 *to, const Packet4bf &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< bfloat16 > (bfloat16 *to, const Packet4bf &from)
template<>
EIGEN_STRONG_INLINE Packet4bf	ploaddup< Packet4bf > (const bfloat16 *from)
template<>
EIGEN_STRONG_INLINE Packet4bf	pabs (const Packet4bf &a)
template<>
EIGEN_STRONG_INLINE Packet4bf	pmin< PropagateNumbers, Packet4bf > (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	pmin< PropagateNaN, Packet4bf > (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	pmin< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	pmax< PropagateNumbers, Packet4bf > (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	pmax< PropagateNaN, Packet4bf > (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	pmax< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	plset< Packet4bf > (const bfloat16 &a)
template<>
EIGEN_STRONG_INLINE Packet4bf	por (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	pxor (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	pand (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	pandnot (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4bf	pselect (const Packet4bf &mask, const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	print< Packet4bf > (const Packet4bf &a)
template<>
EIGEN_STRONG_INLINE Packet4bf	pfloor< Packet4bf > (const Packet4bf &a)
template<>
EIGEN_STRONG_INLINE Packet4bf	pceil< Packet4bf > (const Packet4bf &a)
template<>
EIGEN_STRONG_INLINE Packet4bf	pconj (const Packet4bf &a)
template<>
EIGEN_STRONG_INLINE Packet4bf	padd< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	psub< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	pmul< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	pdiv< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	pgather< bfloat16, Packet4bf > (const bfloat16 *from, Index stride)
template<>
EIGEN_STRONG_INLINE void	pscatter< bfloat16, Packet4bf > (bfloat16 *to, const Packet4bf &from, Index stride)
template<>
EIGEN_STRONG_INLINE bfloat16	predux< Packet4bf > (const Packet4bf &a)
template<>
EIGEN_STRONG_INLINE bfloat16	predux_max< Packet4bf > (const Packet4bf &a)
template<>
EIGEN_STRONG_INLINE bfloat16	predux_min< Packet4bf > (const Packet4bf &a)
template<>
EIGEN_STRONG_INLINE bfloat16	predux_mul< Packet4bf > (const Packet4bf &a)
template<>
EIGEN_STRONG_INLINE Packet4bf	preverse< Packet4bf > (const Packet4bf &a)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet4bf, 4 > &kernel)
template<>
EIGEN_STRONG_INLINE Packet4bf	pabsdiff< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	pcmp_eq< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	pcmp_lt< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	pcmp_lt_or_nan< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	pcmp_le< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
template<>
EIGEN_STRONG_INLINE Packet4bf	pnegate< Packet4bf > (const Packet4bf &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pcast< Packet4f, Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2f	pcast< Packet2f, Packet2f > (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE Packet2l	pcast< Packet4f, Packet2l > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2ul	pcast< Packet4f, Packet2ul > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pcast< Packet4f, Packet4i > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2i	pcast< Packet2f, Packet2i > (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE Packet4ui	pcast< Packet4f, Packet4ui > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2ui	pcast< Packet2f, Packet2ui > (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE Packet8s	pcast< Packet4f, Packet8s > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4s	pcast< Packet2f, Packet4s > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pcast< Packet4f, Packet8us > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4us	pcast< Packet2f, Packet4us > (const Packet2f &a, const Packet2f &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pcast< Packet4f, Packet16c > (const Packet4f &a, const Packet4f &b, const Packet4f &c, const Packet4f &d)
template<>
EIGEN_STRONG_INLINE Packet8c	pcast< Packet2f, Packet8c > (const Packet2f &a, const Packet2f &b, const Packet2f &c, const Packet2f &d)
template<>
EIGEN_STRONG_INLINE Packet16uc	pcast< Packet4f, Packet16uc > (const Packet4f &a, const Packet4f &b, const Packet4f &c, const Packet4f &d)
template<>
EIGEN_STRONG_INLINE Packet8uc	pcast< Packet2f, Packet8uc > (const Packet2f &a, const Packet2f &b, const Packet2f &c, const Packet2f &d)
template<>
EIGEN_STRONG_INLINE Packet4f	pcast< Packet16c, Packet4f > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE Packet2f	pcast< Packet8c, Packet2f > (const Packet8c &a)
template<>
EIGEN_STRONG_INLINE Packet2l	pcast< Packet16c, Packet2l > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE Packet2ul	pcast< Packet16c, Packet2ul > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pcast< Packet16c, Packet4i > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE Packet2i	pcast< Packet8c, Packet2i > (const Packet8c &a)
template<>
EIGEN_STRONG_INLINE Packet4ui	pcast< Packet16c, Packet4ui > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE Packet2ui	pcast< Packet8c, Packet2ui > (const Packet8c &a)
template<>
EIGEN_STRONG_INLINE Packet8s	pcast< Packet16c, Packet8s > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE Packet4s	pcast< Packet8c, Packet4s > (const Packet8c &a)
template<>
EIGEN_STRONG_INLINE Packet8us	pcast< Packet16c, Packet8us > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE Packet4us	pcast< Packet8c, Packet4us > (const Packet8c &a)
template<>
EIGEN_STRONG_INLINE Packet16c	pcast< Packet16c, Packet16c > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE Packet8c	pcast< Packet8c, Packet8c > (const Packet8c &a)
template<>
EIGEN_STRONG_INLINE Packet4c	pcast< Packet4c, Packet4c > (const Packet4c &a)
template<>
EIGEN_STRONG_INLINE Packet16uc	pcast< Packet16c, Packet16uc > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE Packet8uc	pcast< Packet8c, Packet8uc > (const Packet8c &a)
template<>
EIGEN_STRONG_INLINE Packet4uc	pcast< Packet4c, Packet4uc > (const Packet4c &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pcast< Packet16uc, Packet4f > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE Packet2f	pcast< Packet8uc, Packet2f > (const Packet8uc &a)
template<>
EIGEN_STRONG_INLINE Packet2ul	pcast< Packet16uc, Packet2ul > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE Packet2l	pcast< Packet16uc, Packet2l > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE Packet4ui	pcast< Packet16uc, Packet4ui > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE Packet2ui	pcast< Packet8uc, Packet2ui > (const Packet8uc &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pcast< Packet16uc, Packet4i > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE Packet2i	pcast< Packet8uc, Packet2i > (const Packet8uc &a)
template<>
EIGEN_STRONG_INLINE Packet8us	pcast< Packet16uc, Packet8us > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE Packet4us	pcast< Packet8uc, Packet4us > (const Packet8uc &a)
template<>
EIGEN_STRONG_INLINE Packet8s	pcast< Packet16uc, Packet8s > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE Packet4s	pcast< Packet8uc, Packet4s > (const Packet8uc &a)
template<>
EIGEN_STRONG_INLINE Packet16uc	pcast< Packet16uc, Packet16uc > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE Packet8uc	pcast< Packet8uc, Packet8uc > (const Packet8uc &a)
template<>
EIGEN_STRONG_INLINE Packet4uc	pcast< Packet4uc, Packet4uc > (const Packet4uc &a)
template<>
EIGEN_STRONG_INLINE Packet16c	pcast< Packet16uc, Packet16c > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE Packet8c	pcast< Packet8uc, Packet8c > (const Packet8uc &a)
template<>
EIGEN_STRONG_INLINE Packet4c	pcast< Packet4uc, Packet4c > (const Packet4uc &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pcast< Packet8s, Packet4f > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE Packet2f	pcast< Packet4s, Packet2f > (const Packet4s &a)
template<>
EIGEN_STRONG_INLINE Packet2l	pcast< Packet8s, Packet2l > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE Packet2ul	pcast< Packet8s, Packet2ul > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pcast< Packet8s, Packet4i > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE Packet2i	pcast< Packet4s, Packet2i > (const Packet4s &a)
template<>
EIGEN_STRONG_INLINE Packet4ui	pcast< Packet8s, Packet4ui > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE Packet2ui	pcast< Packet4s, Packet2ui > (const Packet4s &a)
template<>
EIGEN_STRONG_INLINE Packet8s	pcast< Packet8s, Packet8s > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE Packet4s	pcast< Packet4s, Packet4s > (const Packet4s &a)
template<>
EIGEN_STRONG_INLINE Packet8us	pcast< Packet8s, Packet8us > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE Packet4us	pcast< Packet4s, Packet4us > (const Packet4s &a)
template<>
EIGEN_STRONG_INLINE Packet16c	pcast< Packet8s, Packet16c > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet8c	pcast< Packet4s, Packet8c > (const Packet4s &a, const Packet4s &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pcast< Packet8s, Packet16uc > (const Packet8s &a, const Packet8s &b)
template<>
EIGEN_STRONG_INLINE Packet8uc	pcast< Packet4s, Packet8uc > (const Packet4s &a, const Packet4s &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pcast< Packet8us, Packet4f > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE Packet2f	pcast< Packet4us, Packet2f > (const Packet4us &a)
template<>
EIGEN_STRONG_INLINE Packet2ul	pcast< Packet8us, Packet2ul > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE Packet2l	pcast< Packet8us, Packet2l > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE Packet4ui	pcast< Packet8us, Packet4ui > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE Packet2ui	pcast< Packet4us, Packet2ui > (const Packet4us &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pcast< Packet8us, Packet4i > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE Packet2i	pcast< Packet4us, Packet2i > (const Packet4us &a)
template<>
EIGEN_STRONG_INLINE Packet8us	pcast< Packet8us, Packet8us > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE Packet4us	pcast< Packet4us, Packet4us > (const Packet4us &a)
template<>
EIGEN_STRONG_INLINE Packet8s	pcast< Packet8us, Packet8s > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE Packet4s	pcast< Packet4us, Packet4s > (const Packet4us &a)
template<>
EIGEN_STRONG_INLINE Packet16uc	pcast< Packet8us, Packet16uc > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet8uc	pcast< Packet4us, Packet8uc > (const Packet4us &a, const Packet4us &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pcast< Packet8us, Packet16c > (const Packet8us &a, const Packet8us &b)
template<>
EIGEN_STRONG_INLINE Packet8c	pcast< Packet4us, Packet8c > (const Packet4us &a, const Packet4us &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pcast< Packet4i, Packet4f > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet2f	pcast< Packet2i, Packet2f > (const Packet2i &a)
template<>
EIGEN_STRONG_INLINE Packet2l	pcast< Packet4i, Packet2l > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet2ul	pcast< Packet4i, Packet2ul > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pcast< Packet4i, Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet2i	pcast< Packet2i, Packet2i > (const Packet2i &a)
template<>
EIGEN_STRONG_INLINE Packet4ui	pcast< Packet4i, Packet4ui > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet2ui	pcast< Packet2i, Packet2ui > (const Packet2i &a)
template<>
EIGEN_STRONG_INLINE Packet8s	pcast< Packet4i, Packet8s > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4s	pcast< Packet2i, Packet4s > (const Packet2i &a, const Packet2i &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pcast< Packet4i, Packet8us > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4us	pcast< Packet2i, Packet4us > (const Packet2i &a, const Packet2i &b)
template<>
EIGEN_STRONG_INLINE Packet16c	pcast< Packet4i, Packet16c > (const Packet4i &a, const Packet4i &b, const Packet4i &c, const Packet4i &d)
template<>
EIGEN_STRONG_INLINE Packet8c	pcast< Packet2i, Packet8c > (const Packet2i &a, const Packet2i &b, const Packet2i &c, const Packet2i &d)
template<>
EIGEN_STRONG_INLINE Packet16uc	pcast< Packet4i, Packet16uc > (const Packet4i &a, const Packet4i &b, const Packet4i &c, const Packet4i &d)
template<>
EIGEN_STRONG_INLINE Packet8uc	pcast< Packet2i, Packet8uc > (const Packet2i &a, const Packet2i &b, const Packet2i &c, const Packet2i &d)
template<>
EIGEN_STRONG_INLINE Packet4f	pcast< Packet4ui, Packet4f > (const Packet4ui &a)
template<>
EIGEN_STRONG_INLINE Packet2f	pcast< Packet2ui, Packet2f > (const Packet2ui &a)
template<>
EIGEN_STRONG_INLINE Packet2ul	pcast< Packet4ui, Packet2ul > (const Packet4ui &a)
template<>
EIGEN_STRONG_INLINE Packet2l	pcast< Packet4ui, Packet2l > (const Packet4ui &a)
template<>
EIGEN_STRONG_INLINE Packet4ui	pcast< Packet4ui, Packet4ui > (const Packet4ui &a)
template<>
EIGEN_STRONG_INLINE Packet2ui	pcast< Packet2ui, Packet2ui > (const Packet2ui &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pcast< Packet4ui, Packet4i > (const Packet4ui &a)
template<>
EIGEN_STRONG_INLINE Packet2i	pcast< Packet2ui, Packet2i > (const Packet2ui &a)
template<>
EIGEN_STRONG_INLINE Packet8us	pcast< Packet4ui, Packet8us > (const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_STRONG_INLINE Packet4us	pcast< Packet2ui, Packet4us > (const Packet2ui &a, const Packet2ui &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pcast< Packet4ui, Packet8s > (const Packet4ui &a, const Packet4ui &b)
template<>
EIGEN_STRONG_INLINE Packet4s	pcast< Packet2ui, Packet4s > (const Packet2ui &a, const Packet2ui &b)
template<>
EIGEN_STRONG_INLINE Packet16uc	pcast< Packet4ui, Packet16uc > (const Packet4ui &a, const Packet4ui &b, const Packet4ui &c, const Packet4ui &d)
template<>
EIGEN_STRONG_INLINE Packet8uc	pcast< Packet2ui, Packet8uc > (const Packet2ui &a, const Packet2ui &b, const Packet2ui &c, const Packet2ui &d)
template<>
EIGEN_STRONG_INLINE Packet16c	pcast< Packet4ui, Packet16c > (const Packet4ui &a, const Packet4ui &b, const Packet4ui &c, const Packet4ui &d)
template<>
EIGEN_STRONG_INLINE Packet8c	pcast< Packet2ui, Packet8c > (const Packet2ui &a, const Packet2ui &b, const Packet2ui &c, const Packet2ui &d)
template<>
EIGEN_STRONG_INLINE Packet4f	pcast< Packet2l, Packet4f > (const Packet2l &a, const Packet2l &b)
template<>
EIGEN_STRONG_INLINE Packet2l	pcast< Packet2l, Packet2l > (const Packet2l &a)
template<>
EIGEN_STRONG_INLINE Packet2ul	pcast< Packet2l, Packet2ul > (const Packet2l &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pcast< Packet2l, Packet4i > (const Packet2l &a, const Packet2l &b)
template<>
EIGEN_STRONG_INLINE Packet4ui	pcast< Packet2l, Packet4ui > (const Packet2l &a, const Packet2l &b)
template<>
EIGEN_STRONG_INLINE Packet8s	pcast< Packet2l, Packet8s > (const Packet2l &a, const Packet2l &b, const Packet2l &c, const Packet2l &d)
template<>
EIGEN_STRONG_INLINE Packet8us	pcast< Packet2l, Packet8us > (const Packet2l &a, const Packet2l &b, const Packet2l &c, const Packet2l &d)
template<>
EIGEN_STRONG_INLINE 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)
template<>
EIGEN_STRONG_INLINE 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)
template<>
EIGEN_STRONG_INLINE Packet4f	pcast< Packet2ul, Packet4f > (const Packet2ul &a, const Packet2ul &b)
template<>
EIGEN_STRONG_INLINE Packet2ul	pcast< Packet2ul, Packet2ul > (const Packet2ul &a)
template<>
EIGEN_STRONG_INLINE Packet2l	pcast< Packet2ul, Packet2l > (const Packet2ul &a)
template<>
EIGEN_STRONG_INLINE Packet4ui	pcast< Packet2ul, Packet4ui > (const Packet2ul &a, const Packet2ul &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pcast< Packet2ul, Packet4i > (const Packet2ul &a, const Packet2ul &b)
template<>
EIGEN_STRONG_INLINE Packet8us	pcast< Packet2ul, Packet8us > (const Packet2ul &a, const Packet2ul &b, const Packet2ul &c, const Packet2ul &d)
template<>
EIGEN_STRONG_INLINE Packet8s	pcast< Packet2ul, Packet8s > (const Packet2ul &a, const Packet2ul &b, const Packet2ul &c, const Packet2ul &d)
template<>
EIGEN_STRONG_INLINE 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)
template<>
EIGEN_STRONG_INLINE 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)
template<>
EIGEN_STRONG_INLINE Packet2f	preinterpret< Packet2f, Packet2i > (const Packet2i &a)
template<>
EIGEN_STRONG_INLINE Packet2f	preinterpret< Packet2f, Packet2ui > (const Packet2ui &a)
template<>
EIGEN_STRONG_INLINE Packet4f	preinterpret< Packet4f, Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4f	preinterpret< Packet4f, Packet4ui > (const Packet4ui &a)
template<>
EIGEN_STRONG_INLINE Packet4c	preinterpret< Packet4c, Packet4uc > (const Packet4uc &a)
template<>
EIGEN_STRONG_INLINE Packet8c	preinterpret< Packet8c, Packet8uc > (const Packet8uc &a)
template<>
EIGEN_STRONG_INLINE Packet16c	preinterpret< Packet16c, Packet16uc > (const Packet16uc &a)
template<>
EIGEN_STRONG_INLINE Packet4uc	preinterpret< Packet4uc, Packet4c > (const Packet4c &a)
template<>
EIGEN_STRONG_INLINE Packet8uc	preinterpret< Packet8uc, Packet8c > (const Packet8c &a)
template<>
EIGEN_STRONG_INLINE Packet16uc	preinterpret< Packet16uc, Packet16c > (const Packet16c &a)
template<>
EIGEN_STRONG_INLINE Packet4s	preinterpret< Packet4s, Packet4us > (const Packet4us &a)
template<>
EIGEN_STRONG_INLINE Packet8s	preinterpret< Packet8s, Packet8us > (const Packet8us &a)
template<>
EIGEN_STRONG_INLINE Packet4us	preinterpret< Packet4us, Packet4s > (const Packet4s &a)
template<>
EIGEN_STRONG_INLINE Packet8us	preinterpret< Packet8us, Packet8s > (const Packet8s &a)
template<>
EIGEN_STRONG_INLINE Packet2i	preinterpret< Packet2i, Packet2f > (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE Packet2i	preinterpret< Packet2i, Packet2ui > (const Packet2ui &a)
template<>
EIGEN_STRONG_INLINE Packet4i	preinterpret< Packet4i, Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4i	preinterpret< Packet4i, Packet4ui > (const Packet4ui &a)
template<>
EIGEN_STRONG_INLINE Packet2ui	preinterpret< Packet2ui, Packet2f > (const Packet2f &a)
template<>
EIGEN_STRONG_INLINE Packet2ui	preinterpret< Packet2ui, Packet2i > (const Packet2i &a)
template<>
EIGEN_STRONG_INLINE Packet4ui	preinterpret< Packet4ui, Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4ui	preinterpret< Packet4ui, Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet2l	preinterpret< Packet2l, Packet2ul > (const Packet2ul &a)
template<>
EIGEN_STRONG_INLINE Packet2ul	preinterpret< Packet2ul, Packet2l > (const Packet2l &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	padd< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	psub< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pnegate (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pconj (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pmul< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	ptrue< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pand< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	por< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pxor< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pandnot< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pload< Packet2cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet2cf	ploadu< Packet2cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet2cf	pset1< Packet2cf > (const std::complex< float > &from)
template<>
EIGEN_STRONG_INLINE Packet2cf	ploaddup< Packet2cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE void	pstore< std::complex< float > > (std::complex< float > *to, const Packet2cf &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< std::complex< float > > (std::complex< float > *to, const Packet2cf &from)
template<>
EIGEN_DEVICE_FUNC Packet2cf	pgather< std::complex< float >, Packet2cf > (const std::complex< float > *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< std::complex< float >, Packet2cf > (std::complex< float > *to, const Packet2cf &from, Index stride)
template<>
EIGEN_STRONG_INLINE void	prefetch< std::complex< float > > (const std::complex< float > *addr)
template<>
EIGEN_STRONG_INLINE std::complex< float >	pfirst< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	preverse (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux_mul< Packet2cf > (const Packet2cf &a)
EIGEN_STRONG_INLINE Packet2cf	pcplxflip (const Packet2cf &x)
template<>
EIGEN_STRONG_INLINE Packet2cf	pdiv< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	padd< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	psub< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pnegate (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	pconj (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	pmul< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	ptrue< Packet1cd > (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	pand< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	por< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pxor< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pandnot< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pload< Packet1cd > (const std::complex< double > *from)
template<>
EIGEN_STRONG_INLINE Packet1cd	ploadu< Packet1cd > (const std::complex< double > *from)
template<>
EIGEN_STRONG_INLINE Packet1cd	pset1< Packet1cd > (const std::complex< double > &from)
template<>
EIGEN_STRONG_INLINE Packet1cd	ploaddup< Packet1cd > (const std::complex< double > *from)
template<>
EIGEN_STRONG_INLINE void	pstore< std::complex< double > > (std::complex< double > *to, const Packet1cd &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< std::complex< double > > (std::complex< double > *to, const Packet1cd &from)
template<>
EIGEN_STRONG_INLINE void	prefetch< std::complex< double > > (const std::complex< double > *addr)
template<>
EIGEN_STRONG_INLINE std::complex< double >	pfirst< Packet1cd > (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	preverse (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE std::complex< double >	predux< Packet1cd > (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE std::complex< double >	predux_mul< Packet1cd > (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	pdiv< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pcmp_eq (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pcmp_eq (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pblend (const Selector< 2 > &ifPacket, const Packet2cf &thenPacket, const Packet2cf &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet1cd	psqrt< Packet1cd > (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	psqrt< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	plog< Packet4f > (const Packet4f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d	plog< Packet2d > (const Packet2d &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	plog2< Packet4f > (const Packet4f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d	plog2< Packet2d > (const Packet2d &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	plog1p< Packet4f > (const Packet4f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	pexpm1< Packet4f > (const Packet4f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	pexp< Packet4f > (const Packet4f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d	pexp< Packet2d > (const Packet2d &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	psin< Packet4f > (const Packet4f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	pcos< Packet4f > (const Packet4f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	psqrt< Packet4f > (const Packet4f &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d	psqrt< Packet2d > (const Packet2d &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16b	psqrt< Packet16b > (const Packet16b &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	prsqrt< Packet4f > (const Packet4f &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d	prsqrt< Packet2d > (const Packet2d &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	ptanh< Packet4f > (const Packet4f &x)
EIGEN_STRONG_INLINE Packet2d	vec2d_unpacklo (const Packet2d &a, const Packet2d &b)
EIGEN_STRONG_INLINE Packet2d	vec2d_unpackhi (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pset1< Packet4f > (const float &from)
template<>
EIGEN_STRONG_INLINE Packet2d	pset1< Packet2d > (const double &from)
template<>
EIGEN_STRONG_INLINE Packet4i	pset1< Packet4i > (const int &from)
template<>
EIGEN_STRONG_INLINE Packet16b	pset1< Packet16b > (const bool &from)
template<>
EIGEN_STRONG_INLINE Packet4f	pset1frombits< Packet4f > (unsigned int from)
template<>
EIGEN_STRONG_INLINE Packet2d	pset1frombits< Packet2d > (uint64_t from)
template<>
EIGEN_STRONG_INLINE Packet4f	peven_mask (const Packet4f &)
template<>
EIGEN_STRONG_INLINE Packet4i	peven_mask (const Packet4i &)
template<>
EIGEN_STRONG_INLINE Packet2d	peven_mask (const Packet2d &)
template<>
EIGEN_STRONG_INLINE Packet4f	pzero (const Packet4f &)
template<>
EIGEN_STRONG_INLINE Packet2d	pzero (const Packet2d &)
template<>
EIGEN_STRONG_INLINE Packet4i	pzero (const Packet4i &)
template<>
EIGEN_STRONG_INLINE Packet4f	plset< Packet4f > (const float &a)
template<>
EIGEN_STRONG_INLINE Packet2d	plset< Packet2d > (const double &a)
template<>
EIGEN_STRONG_INLINE Packet4i	plset< Packet4i > (const int &a)
template<>
EIGEN_STRONG_INLINE Packet4f	padd< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2d	padd< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	padd< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet16b	padd< Packet16b > (const Packet16b &a, const Packet16b &b)
template<>
EIGEN_STRONG_INLINE Packet4f	psub< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2d	psub< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	psub< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet16b	psub< Packet16b > (const Packet16b &a, const Packet16b &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pxor< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	paddsub< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pxor< Packet2d > (const Packet2d &, const Packet2d &)
template<>
EIGEN_STRONG_INLINE Packet2d	paddsub< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pnegate (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pnegate (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pnegate (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet16b	pnegate (const Packet16b &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pconj (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pconj (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pconj (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pmul< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pmul< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pmul< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet16b	pmul< Packet16b > (const Packet16b &a, const Packet16b &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pdiv< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pdiv< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pmadd (const Packet4i &a, const Packet4i &b, const Packet4i &c)
template<>
EIGEN_DEVICE_FUNC Packet16b	pselect (const Packet16b &mask, const Packet16b &a, const Packet16b &b)
template<>
EIGEN_STRONG_INLINE Packet4i	ptrue< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet16b	ptrue< Packet16b > (const Packet16b &a)
template<>
EIGEN_STRONG_INLINE Packet4f	ptrue< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2d	ptrue< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pand< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pand< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pand< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet16b	pand< Packet16b > (const Packet16b &a, const Packet16b &b)
template<>
EIGEN_STRONG_INLINE Packet4f	por< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2d	por< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	por< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet16b	por< Packet16b > (const Packet16b &a, const Packet16b &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pxor< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pxor< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pxor< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet16b	pxor< Packet16b > (const Packet16b &a, const Packet16b &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pandnot< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pandnot< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pandnot< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pcmp_le (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pcmp_lt (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pcmp_lt_or_nan (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pcmp_eq (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pcmp_le (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pcmp_lt (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pcmp_lt_or_nan (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pcmp_eq (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pcmp_lt (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pcmp_eq (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet16b	pcmp_eq (const Packet16b &a, const Packet16b &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pcmp_le (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pmin< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pmin< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pmin< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pmax< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pmax< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pmax< Packet4i > (const Packet4i &a, const Packet4i &b)
template<typename Packet , typename Op >
EIGEN_STRONG_INLINE Packet	pminmax_propagate_numbers (const Packet &a, const Packet &b, Op op)
template<typename Packet , typename Op >
EIGEN_STRONG_INLINE Packet	pminmax_propagate_nan (const Packet &a, const Packet &b, Op op)
template<>
EIGEN_STRONG_INLINE Packet4f	pmin< PropagateNumbers, Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pmin< PropagateNumbers, Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pmax< PropagateNumbers, Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pmax< PropagateNumbers, Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pmin< PropagateNaN, Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pmin< PropagateNaN, Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pmax< PropagateNaN, Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pmax< PropagateNaN, Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pabs (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pabs (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pabs (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4f	print (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2d	print (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pfloor< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pfloor< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pceil< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pceil< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pload< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet2d	pload< Packet2d > (const double *from)
template<>
EIGEN_STRONG_INLINE Packet4i	pload< Packet4i > (const int *from)
template<>
EIGEN_STRONG_INLINE Packet16b	pload< Packet16b > (const bool *from)
template<>
EIGEN_STRONG_INLINE Packet4f	ploadu< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet2d	ploadu< Packet2d > (const double *from)
template<>
EIGEN_STRONG_INLINE Packet4i	ploadu< Packet4i > (const int *from)
template<>
EIGEN_STRONG_INLINE Packet16b	ploadu< Packet16b > (const bool *from)
template<>
EIGEN_STRONG_INLINE Packet4f	ploaddup< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet2d	ploaddup< Packet2d > (const double *from)
template<>
EIGEN_STRONG_INLINE Packet4i	ploaddup< Packet4i > (const int *from)
template<>
EIGEN_STRONG_INLINE Packet16b	ploaddup< Packet16b > (const bool *from)
template<>
EIGEN_STRONG_INLINE Packet16b	ploadquad< Packet16b > (const bool *from)
template<>
EIGEN_STRONG_INLINE void	pstore< float > (float *to, const Packet4f &from)
template<>
EIGEN_STRONG_INLINE void	pstore< double > (double *to, const Packet2d &from)
template<>
EIGEN_STRONG_INLINE void	pstore< int > (int *to, const Packet4i &from)
template<>
EIGEN_STRONG_INLINE void	pstore< bool > (bool *to, const Packet16b &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< double > (double *to, const Packet2d &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< float > (float *to, const Packet4f &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< int > (int *to, const Packet4i &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< bool > (bool *to, const Packet16b &from)
template<>
EIGEN_DEVICE_FUNC Packet4f	pgather< float, Packet4f > (const float *from, Index stride)
template<>
EIGEN_DEVICE_FUNC Packet2d	pgather< double, Packet2d > (const double *from, Index stride)
template<>
EIGEN_DEVICE_FUNC Packet4i	pgather< int, Packet4i > (const int *from, Index stride)
template<>
EIGEN_DEVICE_FUNC Packet16b	pgather< bool, Packet16b > (const bool *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< float, Packet4f > (float *to, const Packet4f &from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< double, Packet2d > (double *to, const Packet2d &from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< int, Packet4i > (int *to, const Packet4i &from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< bool, Packet16b > (bool *to, const Packet16b &from, Index stride)
template<>
EIGEN_STRONG_INLINE void	pstore1< Packet4f > (float *to, const float &a)
template<>
EIGEN_STRONG_INLINE void	pstore1< Packet2d > (double *to, const double &a)
template<>
EIGEN_STRONG_INLINE void	prefetch< float > (const float *addr)
template<>
EIGEN_STRONG_INLINE void	prefetch< double > (const double *addr)
template<>
EIGEN_STRONG_INLINE void	prefetch< int > (const int *addr)
template<>
EIGEN_STRONG_INLINE float	pfirst< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE double	pfirst< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE int	pfirst< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE bool	pfirst< Packet16b > (const Packet16b &a)
template<>
EIGEN_STRONG_INLINE Packet4f	preverse (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2d	preverse (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet4i	preverse (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet16b	preverse (const Packet16b &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pfrexp< Packet4f > (const Packet4f &a, Packet4f &exponent)
template<>
EIGEN_STRONG_INLINE Packet2d	pfrexp_generic_get_biased_exponent (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pfrexp< Packet2d > (const Packet2d &a, Packet2d &exponent)
template<>
EIGEN_STRONG_INLINE Packet4f	pldexp< Packet4f > (const Packet4f &a, const Packet4f &exponent)
template<>
EIGEN_STRONG_INLINE Packet2d	pldexp< Packet2d > (const Packet2d &a, const Packet2d &exponent)
template<>
EIGEN_STRONG_INLINE void	pbroadcast4< Packet4f > (const float *a, Packet4f &a0, Packet4f &a1, Packet4f &a2, Packet4f &a3)
template<>
EIGEN_STRONG_INLINE void	pbroadcast4< Packet2d > (const double *a, Packet2d &a0, Packet2d &a1, Packet2d &a2, Packet2d &a3)
EIGEN_STRONG_INLINE void	punpackp (Packet4f *vecs)
template<>
EIGEN_STRONG_INLINE float	predux< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE double	predux< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE int	predux< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE bool	predux< Packet16b > (const Packet16b &a)
template<>
EIGEN_STRONG_INLINE float	predux_mul< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE double	predux_mul< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE int	predux_mul< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE bool	predux_mul< Packet16b > (const Packet16b &a)
template<>
EIGEN_STRONG_INLINE float	predux_min< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE double	predux_min< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE int	predux_min< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE float	predux_max< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE double	predux_max< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE int	predux_max< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE bool	predux_any (const Packet4f &x)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet16b, 4 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet16b, 16 > &kernel)
template<>
EIGEN_STRONG_INLINE Packet4i	pblend (const Selector< 4 > &ifPacket, const Packet4i &thenPacket, const Packet4i &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet4f	pblend (const Selector< 4 > &ifPacket, const Packet4f &thenPacket, const Packet4f &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet2d	pblend (const Selector< 2 > &ifPacket, const Packet2d &thenPacket, const Packet2d &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet4i	pcast< Packet4f, Packet4i > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pcast< Packet4i, Packet4f > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pcast< Packet2d, Packet4f > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pcast< Packet4f, Packet2d > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4i	preinterpret< Packet4i, Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	preinterpret< Packet4f, Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet2d	preinterpret< Packet2d, Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4i	preinterpret< Packet4i, Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf	pexp< PacketXf > (const PacketXf &x)
template<>
EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf	plog< PacketXf > (const PacketXf &x)
template<>
EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf	psin< PacketXf > (const PacketXf &x)
template<>
EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf	pcos< PacketXf > (const PacketXf &x)
template<>
EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf	ptanh< PacketXf > (const PacketXf &x)
template<>
EIGEN_STRONG_INLINE void	prefetch< numext::int32_t > (const numext::int32_t *addr)
template<>
EIGEN_STRONG_INLINE PacketXi	pset1< PacketXi > (const numext::int32_t &from)
template<>
EIGEN_STRONG_INLINE PacketXi	plset< PacketXi > (const numext::int32_t &a)
template<>
EIGEN_STRONG_INLINE PacketXi	padd< PacketXi > (const PacketXi &a, const PacketXi &b)
template<>
EIGEN_STRONG_INLINE PacketXi	psub< PacketXi > (const PacketXi &a, const PacketXi &b)
template<>
EIGEN_STRONG_INLINE PacketXi	pnegate (const PacketXi &a)
template<>
EIGEN_STRONG_INLINE PacketXi	pconj (const PacketXi &a)
template<>
EIGEN_STRONG_INLINE PacketXi	pmul< PacketXi > (const PacketXi &a, const PacketXi &b)
template<>
EIGEN_STRONG_INLINE PacketXi	pdiv< PacketXi > (const PacketXi &a, const PacketXi &b)
template<>
EIGEN_STRONG_INLINE PacketXi	pmadd (const PacketXi &a, const PacketXi &b, const PacketXi &c)
template<>
EIGEN_STRONG_INLINE PacketXi	pmin< PacketXi > (const PacketXi &a, const PacketXi &b)
template<>
EIGEN_STRONG_INLINE PacketXi	pmax< PacketXi > (const PacketXi &a, const PacketXi &b)
template<>
EIGEN_STRONG_INLINE PacketXi	pcmp_le< PacketXi > (const PacketXi &a, const PacketXi &b)
template<>
EIGEN_STRONG_INLINE PacketXi	pcmp_lt< PacketXi > (const PacketXi &a, const PacketXi &b)
template<>
EIGEN_STRONG_INLINE PacketXi	pcmp_eq< PacketXi > (const PacketXi &a, const PacketXi &b)
template<>
EIGEN_STRONG_INLINE PacketXi	ptrue< PacketXi > (const PacketXi &)
template<>
EIGEN_STRONG_INLINE PacketXi	pzero< PacketXi > (const PacketXi &)
template<>
EIGEN_STRONG_INLINE PacketXi	pand< PacketXi > (const PacketXi &a, const PacketXi &b)
template<>
EIGEN_STRONG_INLINE PacketXi	por< PacketXi > (const PacketXi &a, const PacketXi &b)
template<>
EIGEN_STRONG_INLINE PacketXi	pxor< PacketXi > (const PacketXi &a, const PacketXi &b)
template<>
EIGEN_STRONG_INLINE PacketXi	pandnot< PacketXi > (const PacketXi &a, const PacketXi &b)
template<int N>
EIGEN_STRONG_INLINE PacketXi	parithmetic_shift_right (PacketXi a)
template<int N>
EIGEN_STRONG_INLINE PacketXi	plogical_shift_right (PacketXi a)
template<int N>
EIGEN_STRONG_INLINE PacketXi	plogical_shift_left (PacketXi a)
template<>
EIGEN_STRONG_INLINE PacketXi	pload< PacketXi > (const numext::int32_t *from)
template<>
EIGEN_STRONG_INLINE PacketXi	ploadu< PacketXi > (const numext::int32_t *from)
template<>
EIGEN_STRONG_INLINE PacketXi	ploaddup< PacketXi > (const numext::int32_t *from)
template<>
EIGEN_STRONG_INLINE PacketXi	ploadquad< PacketXi > (const numext::int32_t *from)
template<>
EIGEN_STRONG_INLINE void	pstore< numext::int32_t > (numext::int32_t *to, const PacketXi &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< numext::int32_t > (numext::int32_t *to, const PacketXi &from)
template<>
EIGEN_DEVICE_FUNC PacketXi	pgather< numext::int32_t, PacketXi > (const numext::int32_t *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< numext::int32_t, PacketXi > (numext::int32_t *to, const PacketXi &from, Index stride)
template<>
EIGEN_STRONG_INLINE numext::int32_t	pfirst< PacketXi > (const PacketXi &a)
template<>
EIGEN_STRONG_INLINE PacketXi	preverse (const PacketXi &a)
template<>
EIGEN_STRONG_INLINE PacketXi	pabs (const PacketXi &a)
template<>
EIGEN_STRONG_INLINE numext::int32_t	predux< PacketXi > (const PacketXi &a)
template<>
EIGEN_STRONG_INLINE numext::int32_t	predux_mul< PacketXi > (const PacketXi &a)
template<>
EIGEN_STRONG_INLINE numext::int32_t	predux_min< PacketXi > (const PacketXi &a)
template<>
EIGEN_STRONG_INLINE numext::int32_t	predux_max< PacketXi > (const PacketXi &a)
template<int N>
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< PacketXi, N > &kernel)
template<>
EIGEN_STRONG_INLINE PacketXf	pset1< PacketXf > (const float &from)
template<>
EIGEN_STRONG_INLINE PacketXf	pset1frombits< PacketXf > (numext::uint32_t from)
template<>
EIGEN_STRONG_INLINE PacketXf	plset< PacketXf > (const float &a)
template<>
EIGEN_STRONG_INLINE PacketXf	padd< PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	psub< PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	pnegate (const PacketXf &a)
template<>
EIGEN_STRONG_INLINE PacketXf	pconj (const PacketXf &a)
template<>
EIGEN_STRONG_INLINE PacketXf	pmul< PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	pdiv< PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	pmadd (const PacketXf &a, const PacketXf &b, const PacketXf &c)
template<>
EIGEN_STRONG_INLINE PacketXf	pmin< PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	pmin< PropagateNaN, PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	pmin< PropagateNumbers, PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	pmax< PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	pmax< PropagateNaN, PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	pmax< PropagateNumbers, PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	pcmp_le< PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	pcmp_lt< PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	pcmp_eq< PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	pcmp_lt_or_nan< PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	pfloor< PacketXf > (const PacketXf &a)
template<>
EIGEN_STRONG_INLINE PacketXf	ptrue< PacketXf > (const PacketXf &)
template<>
EIGEN_STRONG_INLINE PacketXf	pand< PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	por< PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	pxor< PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	pandnot< PacketXf > (const PacketXf &a, const PacketXf &b)
template<>
EIGEN_STRONG_INLINE PacketXf	pload< PacketXf > (const float *from)
template<>
EIGEN_STRONG_INLINE PacketXf	ploadu< PacketXf > (const float *from)
template<>
EIGEN_STRONG_INLINE PacketXf	ploaddup< PacketXf > (const float *from)
template<>
EIGEN_STRONG_INLINE PacketXf	ploadquad< PacketXf > (const float *from)
template<>
EIGEN_STRONG_INLINE void	pstore< float > (float *to, const PacketXf &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< float > (float *to, const PacketXf &from)
template<>
EIGEN_DEVICE_FUNC PacketXf	pgather< float, PacketXf > (const float *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< float, PacketXf > (float *to, const PacketXf &from, Index stride)
template<>
EIGEN_STRONG_INLINE float	pfirst< PacketXf > (const PacketXf &a)
template<>
EIGEN_STRONG_INLINE PacketXf	preverse (const PacketXf &a)
template<>
EIGEN_STRONG_INLINE PacketXf	pabs (const PacketXf &a)
template<>
EIGEN_STRONG_INLINE PacketXf	pfrexp< PacketXf > (const PacketXf &a, PacketXf &exponent)
template<>
EIGEN_STRONG_INLINE float	predux< PacketXf > (const PacketXf &a)
template<>
EIGEN_STRONG_INLINE float	predux_mul< PacketXf > (const PacketXf &a)
template<>
EIGEN_STRONG_INLINE float	predux_min< PacketXf > (const PacketXf &a)
template<>
EIGEN_STRONG_INLINE float	predux_max< PacketXf > (const PacketXf &a)
template<int N>
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< PacketXf, N > &kernel)
template<>
EIGEN_STRONG_INLINE PacketXf	pldexp< PacketXf > (const PacketXf &a, const PacketXf &exponent)
template<>
EIGEN_STRONG_INLINE PacketXf	pcast< PacketXi, PacketXf > (const PacketXi &a)
template<>
EIGEN_STRONG_INLINE PacketXi	pcast< PacketXf, PacketXi > (const PacketXf &a)
template<>
EIGEN_STRONG_INLINE PacketXf	preinterpret< PacketXf, PacketXi > (const PacketXi &a)
template<>
EIGEN_STRONG_INLINE PacketXi	preinterpret< PacketXi, PacketXf > (const PacketXf &a)
template<typename packet_type , int Alignment, typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type	ploadt_ro (const Eigen::TensorSycl::internal::RangeAccess< cl::sycl::access::mode::read_write, T > &from)
template<typename packet_type , int Alignment>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type	ploadt (const Eigen::TensorSycl::internal::RangeAccess< cl::sycl::access::mode::read_write, typename unpacket_traits< packet_type >::type > &from)
template<typename scalar , typename packet_type , int Alignment>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void	pstoret (Eigen::TensorSycl::internal::RangeAccess< cl::sycl::access::mode::read_write, typename unpacket_traits< packet_type >::type > to, const packet_type &from)
template<>
EIGEN_STRONG_INLINE Packet1cd	pload< Packet1cd > (const std::complex< double > *from)
template<>
EIGEN_STRONG_INLINE Packet1cd	ploadu< Packet1cd > (const std::complex< double > *from)
template<>
EIGEN_STRONG_INLINE void	pstore< std::complex< double > > (std::complex< double > *to, const Packet1cd &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< std::complex< double > > (std::complex< double > *to, const Packet1cd &from)
template<>
EIGEN_STRONG_INLINE Packet1cd	pset1< Packet1cd > (const std::complex< double > &from)
template<>
EIGEN_DEVICE_FUNC Packet1cd	pgather< std::complex< double >, Packet1cd > (const std::complex< double > *from, Index stride EIGEN_UNUSED)
template<>
EIGEN_DEVICE_FUNC void	pscatter< std::complex< double >, Packet1cd > (std::complex< double > *to, const Packet1cd &from, Index stride EIGEN_UNUSED)
template<>
EIGEN_STRONG_INLINE Packet1cd	padd< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	psub< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pnegate (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	pconj (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	pmul< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pand< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	por< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pxor< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pandnot< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	ploaddup< Packet1cd > (const std::complex< double > *from)
template<>
EIGEN_STRONG_INLINE Packet1cd	pcmp_eq (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE void	prefetch< std::complex< double > > (const std::complex< double > *addr)
template<>
EIGEN_STRONG_INLINE std::complex< double >	pfirst< Packet1cd > (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	preverse (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE std::complex< double >	predux< Packet1cd > (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE std::complex< double >	predux_mul< Packet1cd > (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	pdiv< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pload< Packet2cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet2cf	ploadu< Packet2cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE void	pstore< std::complex< float > > (std::complex< float > *to, const Packet2cf &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< std::complex< float > > (std::complex< float > *to, const Packet2cf &from)
template<>
EIGEN_STRONG_INLINE std::complex< float >	pfirst< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pset1< Packet2cf > (const std::complex< float > &from)
template<>
EIGEN_DEVICE_FUNC Packet2cf	pgather< std::complex< float >, Packet2cf > (const std::complex< float > *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< std::complex< float >, Packet2cf > (std::complex< float > *to, const Packet2cf &from, Index stride)
template<>
EIGEN_STRONG_INLINE Packet2cf	padd< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	psub< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pnegate (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pand< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	por< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pxor< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pandnot< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	ploaddup< Packet2cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE void	prefetch< std::complex< float > > (const std::complex< float > *addr)
template<>
EIGEN_STRONG_INLINE Packet2cf	pcmp_eq (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pconj (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pmul< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	preverse (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux_mul< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pdiv< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pblend (const Selector< 2 > &ifPacket, const Packet2cf &thenPacket, const Packet2cf &elsePacket)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d	pexp< Packet2d > (const Packet2d &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	pexp< Packet4f > (const Packet4f &_x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d	psqrt< Packet2d > (const Packet2d &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	psqrt< Packet4f > (const Packet4f &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d	prsqrt< Packet2d > (const Packet2d &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	prsqrt< Packet4f > (const Packet4f &x)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	ptanh< Packet4f > (const Packet4f &x)
template<>
EIGEN_STRONG_INLINE Packet4i	pload< Packet4i > (const int *from)
template<>
EIGEN_STRONG_INLINE Packet2d	pload< Packet2d > (const double *from)
template<>
EIGEN_STRONG_INLINE void	pstore< int > (int *to, const Packet4i &from)
template<>
EIGEN_STRONG_INLINE void	pstore< double > (double *to, const Packet2d &from)
template<>
EIGEN_STRONG_INLINE Packet4i	pset1< Packet4i > (const int &from)
template<>
EIGEN_STRONG_INLINE Packet2d	pset1< Packet2d > (const double &from)
template<>
EIGEN_STRONG_INLINE void	pbroadcast4< Packet4i > (const int *a, Packet4i &a0, Packet4i &a1, Packet4i &a2, Packet4i &a3)
template<>
EIGEN_STRONG_INLINE void	pbroadcast4< Packet2d > (const double *a, Packet2d &a0, Packet2d &a1, Packet2d &a2, Packet2d &a3)
template<>
EIGEN_DEVICE_FUNC Packet4i	pgather< int, Packet4i > (const int *from, Index stride)
template<>
EIGEN_DEVICE_FUNC Packet2d	pgather< double, Packet2d > (const double *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< int, Packet4i > (int *to, const Packet4i &from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< double, Packet2d > (double *to, const Packet2d &from, Index stride)
template<>
EIGEN_STRONG_INLINE Packet4i	padd< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2d	padd< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	psub< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2d	psub< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pmul< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pmul< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pdiv< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pdiv< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pnegate (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pnegate (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pconj (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pconj (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pmadd (const Packet4i &a, const Packet4i &b, const Packet4i &c)
template<>
EIGEN_STRONG_INLINE Packet2d	pmadd (const Packet2d &a, const Packet2d &b, const Packet2d &c)
template<>
EIGEN_STRONG_INLINE Packet4i	plset< Packet4i > (const int &a)
template<>
EIGEN_STRONG_INLINE Packet2d	plset< Packet2d > (const double &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pmin< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pmin< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pmax< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pmax< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pand< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pand< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	por< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2d	por< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pxor< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pxor< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet4i	pandnot< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pandnot< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
EIGEN_STRONG_INLINE Packet2d	pround< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pceil< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pfloor< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet4i	ploadu< Packet4i > (const int *from)
template<>
EIGEN_STRONG_INLINE Packet2d	ploadu< Packet2d > (const double *from)
template<>
EIGEN_STRONG_INLINE Packet4i	ploaddup< Packet4i > (const int *from)
template<>
EIGEN_STRONG_INLINE Packet2d	ploaddup< Packet2d > (const double *from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< int > (int *to, const Packet4i &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< double > (double *to, const Packet2d &from)
template<>
EIGEN_STRONG_INLINE void	prefetch< int > (const int *addr)
template<>
EIGEN_STRONG_INLINE void	prefetch< double > (const double *addr)
template<>
EIGEN_STRONG_INLINE int	pfirst< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE double	pfirst< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet4i	preverse (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet2d	preverse (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pabs< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pabs< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE int	predux< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE double	predux< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE int	predux_mul< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE double	predux_mul< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE int	predux_min< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE double	predux_min< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE int	predux_max< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE double	predux_max< Packet2d > (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pblend (const Selector< 4 > &ifPacket, const Packet4i &thenPacket, const Packet4i &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet2d	pblend (const Selector< 2 > &ifPacket, const Packet2d &thenPacket, const Packet2d &elsePacket)
template<int element>
EIGEN_STRONG_INLINE Packet4f	vec_splat_packet4f (const Packet4f &from)
template<>
EIGEN_STRONG_INLINE Packet4f	pload< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE void	pstore< float > (float *to, const Packet4f &from)
template<>
EIGEN_STRONG_INLINE Packet4f	pset1< Packet4f > (const float &from)
template<>
EIGEN_STRONG_INLINE void	pbroadcast4< Packet4f > (const float *a, Packet4f &a0, Packet4f &a1, Packet4f &a2, Packet4f &a3)
template<>
EIGEN_DEVICE_FUNC Packet4f	pgather< float, Packet4f > (const float *from, Index stride)
template<>
EIGEN_DEVICE_FUNC void	pscatter< float, Packet4f > (float *to, const Packet4f &from, Index stride)
template<>
EIGEN_STRONG_INLINE Packet4f	padd< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	psub< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pmul< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pdiv< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pnegate (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pmadd (const Packet4f &a, const Packet4f &b, const Packet4f &c)
template<>
EIGEN_STRONG_INLINE Packet4f	pmin< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pmax< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pand< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	por< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pxor< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pandnot< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pround< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pceil< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pfloor< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	ploaddup< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE float	pfirst< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	preverse (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pabs< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE float	predux< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE float	predux_mul< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE float	predux_min< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE float	predux_max< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pblend (const Selector< 4 > &ifPacket, const Packet4f &thenPacket, const Packet4f &elsePacket)
template<>
Packet4f EIGEN_STRONG_INLINE	pcmp_le< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
Packet4f EIGEN_STRONG_INLINE	pcmp_lt< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
Packet4f EIGEN_STRONG_INLINE	pcmp_eq< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE void	prefetch< float > (const float *addr)
template<>
EIGEN_STRONG_INLINE Packet4f	ploadu< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< float > (float *to, const Packet4f &from)
template<>
EIGEN_STRONG_INLINE Packet4f	plset< Packet4f > (const float &a)
template<typename FirstType , typename SizeType , typename IncrType >
ArithmeticSequence< Index, typename make_size_type< SizeType >::type, IncrType >	makeIndexedViewCompatible (const ArithmeticSequence< FirstType, SizeType, IncrType > &ids, Index size, SpecializedType)
template<typename DstXprType , typename SrcXprType , typename Functor >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	resize_if_allowed (DstXprType &dst, const SrcXprType &src, const Functor &)
template<typename DstXprType , typename SrcXprType , typename T1 , typename T2 >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	resize_if_allowed (DstXprType &dst, const SrcXprType &src, const internal::assign_op< T1, T2 > &)
template<typename DstXprType , typename SrcXprType , typename Functor >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	call_dense_assignment_loop (DstXprType &dst, const SrcXprType &src, const Functor &func)
template<typename DstXprType >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE 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)
template<typename DstXprType , typename SrcXprType >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	call_dense_assignment_loop (DstXprType &dst, const SrcXprType &src)
template<typename Dst , typename Src >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	call_assignment (Dst &dst, const Src &src)
template<typename Dst , typename Src >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	call_assignment (const Dst &dst, const Src &src)
template<typename Dst , typename Src , typename Func >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	call_assignment (Dst &dst, const Src &src, const Func &func, typename enable_if< evaluator_assume_aliasing< Src >::value, void * >::type=0)
template<typename Dst , typename Src , typename Func >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	call_assignment (Dst &dst, const Src &src, const Func &func, typename enable_if<!evaluator_assume_aliasing< Src >::value, void * >::type=0)
template<typename Dst , template< typename > class StorageBase, typename Src , typename Func >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	call_assignment (NoAlias< Dst, StorageBase > &dst, const Src &src, const Func &func)
template<typename Dst , typename Src , typename Func >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	call_assignment_no_alias (Dst &dst, const Src &src, const Func &func)
template<typename Dst , typename Src , typename Func >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	call_restricted_packet_assignment_no_alias (Dst &dst, const Src &src, const Func &func)
template<typename Dst , typename Src >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	call_assignment_no_alias (Dst &dst, const Src &src)
template<typename Dst , typename Src , typename Func >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	call_assignment_no_alias_no_transpose (Dst &dst, const Src &src, const Func &func)
template<typename Dst , typename Src >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	call_assignment_no_alias_no_transpose (Dst &dst, const Src &src)
template<typename Dst , typename Src >
void	check_for_aliasing (const Dst &dst, const Src &src)
template<typename Decomposition >
Decomposition::RealScalar	rcond_invmatrix_L1_norm_estimate (const Decomposition &dec)
template<typename Decomposition >
Decomposition::RealScalar	rcond_estimate_helper (typename Decomposition::RealScalar matrix_norm, const Decomposition &dec)
	Reciprocal condition number estimator.
template<typename T , int Size>
EIGEN_DEVICE_FUNC void	check_static_allocation_size ()
template<typename SrcPacket , typename TgtPacket >
EIGEN_DEVICE_FUNC TgtPacket	pcast (const SrcPacket &a)
template<typename SrcPacket , typename TgtPacket >
EIGEN_DEVICE_FUNC TgtPacket	pcast (const SrcPacket &a, const SrcPacket &)
template<typename SrcPacket , typename TgtPacket >
EIGEN_DEVICE_FUNC TgtPacket	pcast (const SrcPacket &a, const SrcPacket &, const SrcPacket &, const SrcPacket &)
template<typename SrcPacket , typename TgtPacket >
EIGEN_DEVICE_FUNC TgtPacket	pcast (const SrcPacket &a, const SrcPacket &, const SrcPacket &, const SrcPacket &, const SrcPacket &, const SrcPacket &, const SrcPacket &, const SrcPacket &)
template<typename Target , typename Packet >
EIGEN_DEVICE_FUNC Target	preinterpret (const Packet &a)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	padd (const Packet &a, const Packet &b)
template<>
EIGEN_DEVICE_FUNC bool	padd (const bool &a, const bool &b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	psub (const Packet &a, const Packet &b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pnegate (const Packet &a)
template<>
EIGEN_DEVICE_FUNC bool	pnegate (const bool &a)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pconj (const Packet &a)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pmul (const Packet &a, const Packet &b)
template<>
EIGEN_DEVICE_FUNC bool	pmul (const bool &a, const bool &b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pdiv (const Packet &a, const Packet &b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	ptrue (const Packet &a)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pzero (const Packet &a)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pcmp_le (const Packet &a, const Packet &b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pcmp_lt (const Packet &a, const Packet &b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pcmp_eq (const Packet &a, const Packet &b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pcmp_lt_or_nan (const Packet &a, const Packet &b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pand (const Packet &a, const Packet &b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	por (const Packet &a, const Packet &b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pxor (const Packet &a, const Packet &b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pnot (const Packet &a)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pandnot (const Packet &a, const Packet &b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pselect (const Packet &mask, const Packet &a, const Packet &b)
template<>
EIGEN_DEVICE_FUNC bool	pselect< bool > (const bool &cond, const bool &a, const bool &b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pmin (const Packet &a, const Packet &b)
template<int NaNPropagation, typename Packet >
EIGEN_DEVICE_FUNC Packet	pmin (const Packet &a, const Packet &b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pmax (const Packet &a, const Packet &b)
template<int NaNPropagation, typename Packet >
EIGEN_DEVICE_FUNC Packet	pmax (const Packet &a, const Packet &b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pabs (const Packet &a)
template<>
EIGEN_DEVICE_FUNC unsigned int	pabs (const unsigned int &a)
template<>
EIGEN_DEVICE_FUNC unsigned long	pabs (const unsigned long &a)
template<>
EIGEN_DEVICE_FUNC unsigned long long	pabs (const unsigned long long &a)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	paddsub (const Packet &a, const Packet &b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	parg (const Packet &a)
template<int N>
EIGEN_DEVICE_FUNC int	parithmetic_shift_right (const int &a)
template<int N>
EIGEN_DEVICE_FUNC long int	parithmetic_shift_right (const long int &a)
template<int N>
EIGEN_DEVICE_FUNC int	plogical_shift_right (const int &a)
template<int N>
EIGEN_DEVICE_FUNC long int	plogical_shift_right (const long int &a)
template<int N>
EIGEN_DEVICE_FUNC int	plogical_shift_left (const int &a)
template<int N>
EIGEN_DEVICE_FUNC long int	plogical_shift_left (const long int &a)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pfrexp (const Packet &a, Packet &exponent)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pldexp (const Packet &a, const Packet &exponent)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pabsdiff (const Packet &a, const Packet &b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pload (const typename unpacket_traits< Packet >::type *from)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	ploadu (const typename unpacket_traits< Packet >::type *from)
template<typename Packet >
EIGEN_DEVICE_FUNC enable_if< unpacket_traits< Packet >::masked_load_available, Packet >::type	ploadu (const typename unpacket_traits< Packet >::type *from, typename unpacket_traits< Packet >::mask_t umask)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pset1 (const typename unpacket_traits< Packet >::type &a)
template<typename Packet , typename BitsType >
EIGEN_DEVICE_FUNC Packet	pset1frombits (BitsType a)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pload1 (const typename unpacket_traits< Packet >::type *a)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet	ploaddup (const typename unpacket_traits< Packet >::type *from)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	ploadquad (const typename unpacket_traits< Packet >::type *from)
template<typename Packet >
EIGEN_DEVICE_FUNC void	pbroadcast4 (const typename unpacket_traits< Packet >::type *a, Packet &a0, Packet &a1, Packet &a2, Packet &a3)
template<typename Packet >
EIGEN_DEVICE_FUNC void	pbroadcast2 (const typename unpacket_traits< Packet >::type *a, Packet &a0, Packet &a1)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet	plset (const typename unpacket_traits< Packet >::type &a)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	peven_mask (const Packet &)
template<typename Scalar , typename Packet >
EIGEN_DEVICE_FUNC void	pstore (Scalar *to, const Packet &from)
template<typename Scalar , typename Packet >
EIGEN_DEVICE_FUNC void	pstoreu (Scalar *to, const Packet &from)
template<typename Scalar , typename Packet >
EIGEN_DEVICE_FUNC enable_if< unpacket_traits< Packet >::masked_store_available, void >::type	pstoreu (Scalar *to, const Packet &from, typename unpacket_traits< Packet >::mask_t umask)
template<typename Scalar , typename Packet >
EIGEN_DEVICE_FUNC Packet	pgather (const Scalar *from, Index)
template<typename Scalar , typename Packet >
EIGEN_DEVICE_FUNC void	pscatter (Scalar *to, const Packet &from, Index)
template<typename Scalar >
EIGEN_DEVICE_FUNC void	prefetch (const Scalar *addr)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	preverse (const Packet &a)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pcplxflip (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	psin (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pcos (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	ptan (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pasin (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pacos (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	patan (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	psinh (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pcosh (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	ptanh (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pexp (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pexpm1 (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	plog (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	plog1p (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	plog10 (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	plog2 (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	psqrt (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	prsqrt (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pround (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pfloor (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	print (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pceil (const Packet &a)
template<typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type	pfirst (const Packet &a)
template<typename Packet >
EIGEN_DEVICE_FUNC conditional<(unpacket_traits< Packet >::size%8)==0, typenameunpacket_traits< Packet >::half, Packet >::type	predux_half_dowto4 (const Packet &a)
template<typename Packet , typename Op >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type	predux_helper (const Packet &a, Op op)
template<typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type	predux (const Packet &a)
template<typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type	predux_mul (const Packet &a)
template<typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type	predux_min (const Packet &a)
template<int NaNPropagation, typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type	predux_min (const Packet &a)
template<typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type	predux_max (const Packet &a)
template<int NaNPropagation, typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type	predux_max (const Packet &a)
template<typename Packet >
EIGEN_DEVICE_FUNC bool	predux_any (const Packet &a)
template<typename Packet >
void	pstore1 (typename unpacket_traits< Packet >::type *to, const typename unpacket_traits< Packet >::type &a)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pmadd (const Packet &a, const Packet &b, const Packet &c)
template<typename Packet , int Alignment>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet	ploadt (const typename unpacket_traits< Packet >::type *from)
template<typename Scalar , typename Packet , int Alignment>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void	pstoret (Scalar *to, const Packet &from)
template<typename Packet , int LoadMode>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet	ploadt_ro (const typename unpacket_traits< Packet >::type *from)
template<>
std::complex< float >	pmul (const std::complex< float > &a, const std::complex< float > &b)
template<>
std::complex< double >	pmul (const std::complex< double > &a, const std::complex< double > &b)
template<typename Packet >
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet, 1 > &)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pblend (const Selector< unpacket_traits< Packet >::size > &ifPacket, const Packet &thenPacket, const Packet &elsePacket)
template<typename Derived >
std::ostream &	print_matrix (std::ostream &s, const Derived &_m, const IOFormat &fmt)
template<typename T >
EIGEN_DEVICE_FUNC std::complex< T >	complex_sqrt (const std::complex< T > &a_x)
template<typename T >
EIGEN_DEVICE_FUNC std::complex< T >	complex_rsqrt (const std::complex< T > &a_x)
template<typename OldType , typename NewType >
EIGEN_DEVICE_FUNC NewType	cast (const OldType &x)
template<typename T >
EIGEN_DEVICE_FUNC std::complex< T >	complex_log (const std::complex< T > &z)
template<typename Scalar >
	EIGEN_MATHFUNC_RETVAL (random, Scalar) random(const Scalar &x
template<typename Scalar >
	EIGEN_MATHFUNC_RETVAL (random, Scalar) random()
template<typename T >
EIGEN_DEVICE_FUNC internal::enable_if< internal::is_integral< T >::value, bool >::type	isnan_impl (const T &)
template<typename T >
EIGEN_DEVICE_FUNC internal::enable_if< internal::is_integral< T >::value, bool >::type	isinf_impl (const T &)
template<typename T >
EIGEN_DEVICE_FUNC internal::enable_if< internal::is_integral< T >::value, bool >::type	isfinite_impl (const T &)
template<typename T >
EIGEN_DEVICE_FUNC internal::enable_if<(!internal::is_integral< T >::value)&&(!NumTraits< T >::IsComplex), bool >::type	isfinite_impl (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC internal::enable_if<(!internal::is_integral< T >::value)&&(!NumTraits< T >::IsComplex), bool >::type	isinf_impl (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC internal::enable_if<(!internal::is_integral< T >::value)&&(!NumTraits< T >::IsComplex), bool >::type	isnan_impl (const T &x)
template<typename T >
EIGEN_DEVICE_FUNC bool	isfinite_impl (const std::complex< T > &x)
template<typename T >
EIGEN_DEVICE_FUNC bool	isnan_impl (const std::complex< T > &x)
template<typename T >
EIGEN_DEVICE_FUNC bool	isinf_impl (const std::complex< T > &x)
template<typename T >
T	generic_fast_tanh_float (const T &a_x)
template<typename Scalar , typename OtherScalar >
EIGEN_DEVICE_FUNC bool	isMuchSmallerThan (const Scalar &x, const OtherScalar &y, const typename NumTraits< Scalar >::Real &precision=NumTraits< Scalar >::dummy_precision())
template<typename Scalar >
EIGEN_DEVICE_FUNC bool	isApprox (const Scalar &x, const Scalar &y, const typename NumTraits< Scalar >::Real &precision=NumTraits< Scalar >::dummy_precision())
template<typename Scalar >
EIGEN_DEVICE_FUNC bool	isApproxOrLessThan (const Scalar &x, const Scalar &y, const typename NumTraits< Scalar >::Real &precision=NumTraits< Scalar >::dummy_precision())
template<typename RealScalar >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE RealScalar	positive_real_hypot (const RealScalar &x, const RealScalar &y)
template<typename PacketType , typename Func >
EIGEN_DEVICE_FUNC PacketType	packetwise_redux_empty_value (const Func &)
template<typename PacketType , typename Scalar >
EIGEN_DEVICE_FUNC PacketType	packetwise_redux_empty_value (const scalar_product_op< Scalar, Scalar > &)
	EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT (assign_op, scalar_sum_op, add_assign_op)
	EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT (add_assign_op, scalar_sum_op, add_assign_op)
	EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT (sub_assign_op, scalar_sum_op, sub_assign_op)
	EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT (assign_op, scalar_difference_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 (sub_assign_op, scalar_difference_op, add_assign_op)
template<typename Dst , typename Lhs , typename Rhs , typename Func >
void EIGEN_DEVICE_FUNC	outer_product_selector_run (Dst &dst, const Lhs &lhs, const Rhs &rhs, const Func &func, const false_type &)
template<typename Dst , typename Lhs , typename Rhs , typename Func >
void EIGEN_DEVICE_FUNC	outer_product_selector_run (Dst &dst, const Lhs &lhs, const Rhs &rhs, const Func &func, const true_type &)
std::ptrdiff_t	manage_caching_sizes_helper (std::ptrdiff_t a, std::ptrdiff_t b)
void	manage_caching_sizes (Action action, std::ptrdiff_t *l1, std::ptrdiff_t *l2, std::ptrdiff_t *l3)
template<typename LhsScalar , typename RhsScalar , int KcFactor, typename Index >
void	evaluateProductBlockingSizesHeuristic (Index &k, Index &m, Index &n, Index num_threads=1)
template<typename Index >
bool	useSpecificBlockingSizes (Index &k, Index &m, Index &n)
template<typename LhsScalar , typename RhsScalar , int KcFactor, typename Index >
void	computeProductBlockingSizes (Index &k, Index &m, Index &n, Index num_threads=1)
	Computes the blocking parameters for a m x k times k x n matrix product.
template<typename LhsScalar , typename RhsScalar , typename Index >
void	computeProductBlockingSizes (Index &k, Index &m, Index &n, Index num_threads=1)
template<typename Packet >
DoublePacket< Packet >	padd (const DoublePacket< Packet > &a, const DoublePacket< Packet > &b)
template<typename Packet >
const DoublePacket< Packet > &	predux_half_dowto4 (const DoublePacket< Packet > &a, typename enable_if< unpacket_traits< Packet >::size<=8 >::type *=0)
template<typename Packet >
DoublePacket< typename unpacket_traits< Packet >::half >	predux_half_dowto4 (const DoublePacket< Packet > &a, typename enable_if< unpacket_traits< Packet >::size==16 >::type *=0)
template<typename Scalar , typename RealPacket >
void	loadQuadToDoublePacket (const Scalar *b, DoublePacket< RealPacket > &dest, typename enable_if< unpacket_traits< RealPacket >::size<=8 >::type *=0)
template<typename Scalar , typename RealPacket >
void	loadQuadToDoublePacket (const Scalar *b, DoublePacket< RealPacket > &dest, typename enable_if< unpacket_traits< RealPacket >::size==16 >::type *=0)
void	manage_multi_threading (Action action, int *v)
template<bool Condition, typename Functor , typename Index >
void	parallelize_gemm (const Functor &func, Index rows, Index cols, Index depth, bool transpose)
template<typename ExpressionType , typename Scalar >
void	stable_norm_kernel (const ExpressionType &bl, Scalar &ssq, Scalar &scale, Scalar &invScale)
template<typename VectorType , typename RealScalar >
void	stable_norm_impl_inner_step (const VectorType &vec, RealScalar &ssq, RealScalar &scale, RealScalar &invScale)
template<typename VectorType >
VectorType::RealScalar	stable_norm_impl (const VectorType &vec, typename enable_if< VectorType::IsVectorAtCompileTime >::type *=0)
template<typename MatrixType >
MatrixType::RealScalar	stable_norm_impl (const MatrixType &mat, typename enable_if<!MatrixType::IsVectorAtCompileTime >::type *=0)
template<typename Derived >
NumTraits< typenametraits< Derived >::Scalar >::Real	blueNorm_impl (const EigenBase< Derived > &_vec)
template<typename MatrixType , Index Alignment>
void	BlockedInPlaceTranspose (MatrixType &m)
template<int Mode, bool SetOpposite, typename DstXprType , typename SrcXprType , typename Functor >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	call_triangular_assignment_loop (DstXprType &dst, const SrcXprType &src, const Functor &func)
template<int Mode, bool SetOpposite, typename DstXprType , typename SrcXprType >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	call_triangular_assignment_loop (DstXprType &dst, const SrcXprType &src)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T::Scalar *	extract_data (const T &m)
template<typename ResScalar , typename Lhs , typename Rhs >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE ResScalar	combine_scalar_factors (const ResScalar &alpha, const Lhs &lhs, const Rhs &rhs)
template<typename ResScalar , typename Lhs , typename Rhs >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE ResScalar	combine_scalar_factors (const Lhs &lhs, const Rhs &rhs)
Index	eval_expr_given_size (Index x, Index)
template<int N>
FixedInt< N >	eval_expr_given_size (FixedInt< N > x, Index)
template<typename Derived >
Index	eval_expr_given_size (const symbolic::BaseExpr< Derived > &x, Index size)
template<typename T >
EIGEN_CONSTEXPR Index	first (const T &x) EIGEN_NOEXCEPT
template<typename T , typename Q >
const T &	makeIndexedViewCompatible (const T &x, Index, Q)
template<typename T >
enable_if< symbolic::is_symbolic< T >::value, SingleRange >::type	makeIndexedViewCompatible (const T &id, Index size, SpecializedType)
template<typename XprSizeType >
AllRange< get_fixed_value< XprSizeType >::value >	makeIndexedViewCompatible (all_t, XprSizeType size, SpecializedType)
template<typename T >
EIGEN_DEVICE_FUNC Index	get_runtime_value (const T &x)
template<int N>
EIGEN_DEVICE_FUNC Index	get_runtime_value (FixedInt< N >(*)())
bool	copy_bool (bool b)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	ignore_unused_variable (const T &)
EIGEN_DEVICE_FUNC void	throw_std_bad_alloc ()
EIGEN_DEVICE_FUNC void *	handmade_aligned_malloc (std::size_t size, std::size_t alignment=EIGEN_DEFAULT_ALIGN_BYTES)
EIGEN_DEVICE_FUNC void	handmade_aligned_free (void *ptr)
void *	handmade_aligned_realloc (void *ptr, std::size_t size, std::size_t=0)
EIGEN_DEVICE_FUNC void	check_that_malloc_is_allowed ()
EIGEN_DEVICE_FUNC void *	aligned_malloc (std::size_t size)
EIGEN_DEVICE_FUNC void	aligned_free (void *ptr)
void *	aligned_realloc (void *ptr, std::size_t new_size, std::size_t old_size)
template<bool Align>
EIGEN_DEVICE_FUNC void *	conditional_aligned_malloc (std::size_t size)
template<>
EIGEN_DEVICE_FUNC void *	conditional_aligned_malloc< false > (std::size_t size)
template<bool Align>
EIGEN_DEVICE_FUNC void	conditional_aligned_free (void *ptr)
template<>
EIGEN_DEVICE_FUNC void	conditional_aligned_free< false > (void *ptr)
template<bool Align>
void *	conditional_aligned_realloc (void *ptr, std::size_t new_size, std::size_t old_size)
template<>
void *	conditional_aligned_realloc< false > (void *ptr, std::size_t new_size, std::size_t)
template<typename T >
EIGEN_DEVICE_FUNC void	destruct_elements_of_array (T *ptr, std::size_t size)
template<typename T >
EIGEN_DEVICE_FUNC T *	construct_elements_of_array (T *ptr, std::size_t size)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void	check_size_for_overflow (std::size_t size)
template<typename T >
EIGEN_DEVICE_FUNC T *	aligned_new (std::size_t size)
template<typename T , bool Align>
EIGEN_DEVICE_FUNC T *	conditional_aligned_new (std::size_t size)
template<typename T >
EIGEN_DEVICE_FUNC void	aligned_delete (T *ptr, std::size_t size)
template<typename T , bool Align>
EIGEN_DEVICE_FUNC void	conditional_aligned_delete (T *ptr, std::size_t size)
template<typename T , bool Align>
EIGEN_DEVICE_FUNC T *	conditional_aligned_realloc_new (T *pts, std::size_t new_size, std::size_t old_size)
template<typename T , bool Align>
EIGEN_DEVICE_FUNC T *	conditional_aligned_new_auto (std::size_t size)
template<typename T , bool Align>
T *	conditional_aligned_realloc_new_auto (T *pts, std::size_t new_size, std::size_t old_size)
template<typename T , bool Align>
EIGEN_DEVICE_FUNC void	conditional_aligned_delete_auto (T *ptr, std::size_t size)
template<int Alignment, typename Scalar , typename Index >
EIGEN_DEVICE_FUNC Index	first_aligned (const Scalar *array, Index size)
template<typename Scalar , typename Index >
EIGEN_DEVICE_FUNC Index	first_default_aligned (const Scalar *array, Index size)
template<typename Index >
Index	first_multiple (Index size, Index base)
template<typename T >
EIGEN_DEVICE_FUNC void	smart_copy (const T *start, const T *end, T *target)
template<typename T >
void	smart_memmove (const T *start, const T *end, T *target)
template<typename T >
EIGEN_DEVICE_FUNC T *	smart_move (T *start, T *end, T *target)
template<typename T >
void	swap (scoped_array< T > &a, scoped_array< T > &b)
void	queryCacheSizes (int &l1, int &l2, int &l3)
int	queryL1CacheSize ()
int	queryTopLevelCacheSize ()
template<typename T >
EIGEN_CONSTEXPR Index	size (const T &x)
template<typename T , std::size_t N>
EIGEN_CONSTEXPR Index	size (const T(&)[N])
template<typename T >
const T *	return_ptr ()
template<typename SizeType >
Index	get_runtime_reshape_size (SizeType size, Index, Index)
Index	get_runtime_reshape_size (AutoSize_t, Index other, Index total)
template<typename IndexDest , typename IndexSrc >
EIGEN_DEVICE_FUNC IndexDest	convert_index (const IndexSrc &idx)
template<typename T >
EIGEN_DEVICE_FUNC T *	const_cast_ptr (const T *ptr)
template<typename T1 , typename T2 >
EIGEN_DEVICE_FUNC bool	is_same_dense (const T1 &mat1, const T2 &mat2, typename enable_if< possibly_same_dense< T1, T2 >::value >::type *=0)
template<typename T1 , typename T2 >
EIGEN_DEVICE_FUNC bool	is_same_dense (const T1 &, const T2 &, typename enable_if<!possibly_same_dense< T1, T2 >::value >::type *=0)
	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)
	EIGEN_MEMBER_FUNCTOR (blueNorm,(Size+5) *NumTraits< Scalar >::MulCost+(Size-1) *NumTraits< Scalar >::AddCost)
	EIGEN_MEMBER_FUNCTOR (hypotNorm,(Size-1) *functor_traits< scalar_hypot_op< Scalar > >::Cost)
	EIGEN_MEMBER_FUNCTOR (all,(Size-1) *NumTraits< Scalar >::AddCost)
	EIGEN_MEMBER_FUNCTOR (any,(Size-1) *NumTraits< Scalar >::AddCost)
	EIGEN_MEMBER_FUNCTOR (count,(Size-1) *NumTraits< Scalar >::AddCost)
	EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR (sum,(Size-1) *NumTraits< Scalar >::AddCost, 1, internal::scalar_sum_op)
	EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR (minCoeff,(Size-1) *NumTraits< Scalar >::AddCost, 1, internal::scalar_min_op)
	EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR (maxCoeff,(Size-1) *NumTraits< Scalar >::AddCost, 1, internal::scalar_max_op)
	EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR (prod,(Size-1) *NumTraits< Scalar >::MulCost, 1, internal::scalar_product_op)
template<typename MatrixType , typename DiagType , typename SubDiagType >
EIGEN_DEVICE_FUNC ComputationInfo	computeFromTridiagonal_impl (DiagType &diag, SubDiagType &subdiag, const Index maxIterations, bool computeEigenvectors, MatrixType &eivec)
template<typename MatrixType , typename CoeffVectorType >
EIGEN_DEVICE_FUNC void	tridiagonalization_inplace (MatrixType &matA, CoeffVectorType &hCoeffs)
template<typename MatrixType , typename DiagonalType , typename SubDiagonalType , typename CoeffVectorType >
EIGEN_DEVICE_FUNC void	tridiagonalization_inplace (MatrixType &mat, DiagonalType &diag, SubDiagonalType &subdiag, CoeffVectorType &hcoeffs, bool extractQ)
	Performs a full tridiagonalization in place.
template<typename TriangularFactorType , typename VectorsType , typename CoeffsType >
void	make_block_householder_triangular_factor (TriangularFactorType &triFactor, const VectorsType &vectors, const CoeffsType &hCoeffs)
template<typename MatrixType , typename VectorsType , typename CoeffsType >
void	apply_block_householder_on_the_left (MatrixType &mat, const VectorsType &vectors, const CoeffsType &hCoeffs, bool forward)
template<typename MatrixType , typename Rhs , typename Dest , typename Preconditioner >
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 >
EIGEN_DONT_INLINE void	conjugate_gradient (const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, Index &iters, typename Dest::RealScalar &tol_error)
template<typename VectorV , typename VectorI >
Index	QuickSplit (VectorV &row, VectorI &ind, Index ncut)
template<typename MatrixType , typename Rhs , typename Dest , typename Preconditioner >
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)
template<typename VectorX , typename VectorY , typename OtherScalar >
EIGEN_DEVICE_FUNC void	apply_rotation_in_the_plane (DenseBase< VectorX > &xpr_x, DenseBase< VectorY > &xpr_y, const JacobiRotation< OtherScalar > &j)
template<typename Derived >
EIGEN_DEVICE_FUNC const Derived::Scalar	bruteforce_det3_helper (const MatrixBase< Derived > &matrix, int a, int b, int c)
template<typename MatrixType , typename ResultType >
EIGEN_DEVICE_FUNC void	compute_inverse_size2_helper (const MatrixType &matrix, const typename ResultType::Scalar &invdet, ResultType &result)
template<typename MatrixType , int i, int j>
EIGEN_DEVICE_FUNC MatrixType::Scalar	cofactor_3x3 (const MatrixType &m)
template<typename MatrixType , typename ResultType >
EIGEN_DEVICE_FUNC void	compute_inverse_size3_helper (const MatrixType &matrix, const typename ResultType::Scalar &invdet, const Matrix< typename ResultType::Scalar, 3, 1 > &cofactors_col0, ResultType &result)
template<typename Derived >
EIGEN_DEVICE_FUNC const Derived::Scalar	general_det3_helper (const MatrixBase< Derived > &matrix, int i1, int i2, int i3, int j1, int j2, int j3)
template<typename MatrixType , int i, int j>
EIGEN_DEVICE_FUNC MatrixType::Scalar	cofactor_4x4 (const MatrixType &matrix)
template<typename MatrixType , typename TranspositionType >
void	partial_lu_inplace (MatrixType &lu, TranspositionType &row_transpositions, typename TranspositionType::StorageIndex &nb_transpositions)
template<typename MatrixType , typename RealScalar , typename Index >
void	real_2x2_jacobi_svd (const MatrixType &matrix, Index p, Index q, JacobiRotation< RealScalar > *j_left, JacobiRotation< RealScalar > *j_right)
template<typename T >
T	amd_flip (const T &i)
template<typename T >
T	amd_unflip (const T &i)
template<typename T0 , typename T1 >
bool	amd_marked (const T0 *w, const T1 &j)
template<typename T0 , typename T1 >
void	amd_mark (const T0 *w, const T1 &j)
template<typename StorageIndex >
StorageIndex	cs_tdfs (StorageIndex j, StorageIndex k, StorageIndex *head, const StorageIndex *next, StorageIndex *post, StorageIndex *stack)
template<typename Scalar , typename StorageIndex >
void	minimum_degree_ordering (SparseMatrix< Scalar, ColMajor, StorageIndex > &C, PermutationMatrix< Dynamic, Dynamic, StorageIndex > &perm)
template<typename MatrixType >
void	ordering_helper_at_plus_a (const MatrixType &A, MatrixType &symmat)
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, 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, std::complex< float > *vals, int *perm, int *invp, std::complex< 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)
template<typename MatrixType >
void	c_to_fortran_numbering (MatrixType &mat)
template<typename MatrixType >
void	fortran_to_c_numbering (MatrixType &mat)
template<typename MatrixQR , typename HCoeffs >
void	householder_qr_inplace_unblocked (MatrixQR &mat, HCoeffs &hCoeffs, typename MatrixQR::Scalar *tempData=0)
template<typename DstXprType , typename SrcXprType >
void	assign_sparse_to_sparse (DstXprType &dst, const SrcXprType &src)
	EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (assign_op, scalar_sum_op, add_assign_op)
	EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (add_assign_op, scalar_sum_op, add_assign_op)
	EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (sub_assign_op, scalar_sum_op, sub_assign_op)
	EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (assign_op, scalar_difference_op, sub_assign_op)
	EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (add_assign_op, scalar_difference_op, sub_assign_op)
	EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (sub_assign_op, scalar_difference_op, add_assign_op)
template<typename Index , typename IndexVector >
Index	etree_find (Index i, IndexVector &pp)
template<typename MatrixType , typename IndexVector >
int	coletree (const MatrixType &mat, IndexVector &parent, IndexVector &firstRowElt, typename MatrixType::StorageIndex *perm=0)
template<typename IndexVector >
void	nr_etdfs (typename IndexVector::Scalar n, IndexVector &parent, IndexVector &first_kid, IndexVector &next_kid, IndexVector &post, typename IndexVector::Scalar postnum)
template<typename IndexVector >
void	treePostorder (typename IndexVector::Scalar n, IndexVector &parent, IndexVector &post)
	Post order a tree.
template<typename SparseLhsType , typename DenseRhsType , typename DenseResType , typename AlphaType >
void	sparse_time_dense_product (const SparseLhsType &lhs, const DenseRhsType &rhs, DenseResType &res, const AlphaType &alpha)
template<typename InputIterator , typename SparseMatrixType , typename DupFunctor >
void	set_from_triplets (const InputIterator &begin, const InputIterator &end, SparseMatrixType &mat, DupFunctor dup_func)
template<int SrcMode, int DstMode, typename MatrixType , int DestOrder>
void	permute_symm_to_symm (const MatrixType &mat, SparseMatrix< typename MatrixType::Scalar, DestOrder, typename MatrixType::StorageIndex > &_dest, const typename MatrixType::StorageIndex *perm=0)
template<int Mode, typename MatrixType , int DestOrder>
void	permute_symm_to_fullsymm (const MatrixType &mat, SparseMatrix< typename MatrixType::Scalar, DestOrder, typename MatrixType::StorageIndex > &_dest, const typename MatrixType::StorageIndex *perm=0)
template<int Mode, typename SparseLhsType , typename DenseRhsType , typename DenseResType , typename AlphaType >
void	sparse_selfadjoint_time_dense_product (const SparseLhsType &lhs, const DenseRhsType &rhs, DenseResType &res, const AlphaType &alpha)
template<int _SrcMode, int _DstMode, typename MatrixType , int DstOrder>
void	permute_symm_to_symm (const MatrixType &mat, SparseMatrix< typename MatrixType::Scalar, DstOrder, typename MatrixType::StorageIndex > &_dest, const typename MatrixType::StorageIndex *perm)
template<typename Decomposition , typename Rhs , typename Dest >
enable_if< Rhs::ColsAtCompileTime!=1 &&Dest::ColsAtCompileTime!=1 >::type	solve_sparse_through_dense_panels (const Decomposition &dec, const Rhs &rhs, Dest &dest)
template<typename Decomposition , typename Rhs , typename Dest >
enable_if< Rhs::ColsAtCompileTime==1||Dest::ColsAtCompileTime==1 >::type	solve_sparse_through_dense_panels (const Decomposition &dec, const Rhs &rhs, Dest &dest)
template<typename Scalar >
EIGEN_DONT_INLINE void	sparselu_gemm (Index m, Index n, Index d, const Scalar *A, Index lda, const Scalar *B, Index ldb, Scalar *C, Index ldc)
Index	LUnumTempV (Index &m, Index &w, Index &t, Index &b)
template<typename Scalar >
Index	LUTempSpace (Index &m, Index &w)
template<typename MatrixType >
SluMatrix	asSluMatrix (MatrixType &mat)
template<typename Scalar , int Flags, typename Index >
MappedSparseMatrix< Scalar, Flags, Index >	map_superlu (SluMatrix &sluMat)
template<typename MatrixType >
void	upperbidiagonalization_inplace_unblocked (MatrixType &mat, typename MatrixType::RealScalar *diagonal, typename MatrixType::RealScalar *upper_diagonal, typename MatrixType::Scalar *tempData=0)
template<typename MatrixType >
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)
template<typename MatrixType , typename BidiagType >
void	upperbidiagonalization_inplace_blocked (MatrixType &A, BidiagType &bidiagonal, Index maxBlockSize=32, typename MatrixType::Scalar *=0)
template<>
EIGEN_STRONG_INLINE double	cast (const AnnoyingScalar &x)
template<>
EIGEN_STRONG_INLINE float	cast (const AnnoyingScalar &x)
template<typename Dst , template< typename > class StorageBase, typename Src , typename Func >
EIGEN_DEVICE_FUNC void	call_assignment (const NoAlias< Dst, StorageBase > &dst, const Src &src, const Func &func)
template<typename Dst , template< typename > class StorageBase, typename Src , typename Func >
EIGEN_DEVICE_FUNC void	call_restricted_packet_assignment (const NoAlias< Dst, StorageBase > &dst, const Src &src, const Func &func)
template<typename T >
T	negate (const T &x)
template<typename T >
Map< const Array< unsigned char, sizeof(T), 1 > >	bits (const T &x)
template<typename T , typename Bits , typename Func >
T	apply_bit_op (Bits a, Bits b, Func f)
template<typename T >
bool	biteq (T a, T b)
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>
EIGEN_STRONG_INLINE DSizes< std::ptrdiff_t, sizeof...(Indices)>	strides (const Sizes< Indices... > &sizes)
template<DenseIndex n, typename Index , std::size_t Rank>
const Index	array_get (DimensionList< Index, Rank > &)
template<DenseIndex n, typename Index , std::size_t Rank>
const Index	array_get (const DimensionList< Index, Rank > &)
template<typename std::ptrdiff_t... Indices>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t	array_prod (const Sizes< Indices... > &)
template<std::ptrdiff_t n, typename std::ptrdiff_t... Indices>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t	array_get (const Sizes< Indices... > &)
template<std::ptrdiff_t n>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t	array_get (const Sizes<> &)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T	RandomToTypeUniform (uint64_t *state, uint64_t stream)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half	RandomToTypeUniform< Eigen::half > (uint64_t *state, uint64_t stream)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::bfloat16	RandomToTypeUniform< Eigen::bfloat16 > (uint64_t *state, uint64_t stream)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float	RandomToTypeUniform< float > (uint64_t *state, uint64_t stream)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double	RandomToTypeUniform< double > (uint64_t *state, uint64_t stream)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex< float >	RandomToTypeUniform< std::complex< float > > (uint64_t *state, uint64_t stream)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex< double >	RandomToTypeUniform< std::complex< double > > (uint64_t *state, uint64_t stream)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T	RandomToTypeNormal (uint64_t *state, uint64_t stream)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex< float >	RandomToTypeNormal< std::complex< float > > (uint64_t *state, uint64_t stream)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex< double >	RandomToTypeNormal< std::complex< double > > (uint64_t *state, uint64_t stream)
template<typename Self >
EIGEN_STRONG_INLINE void	ReduceScalar (Self &self, Index offset, typename Self::CoeffReturnType *data)
template<typename Self >
EIGEN_STRONG_INLINE void	ReducePacket (Self &self, Index offset, typename Self::CoeffReturnType *data)
template<typename HL , typename LL , typename HR , typename LR >
EIGEN_DEVICE_FUNC 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_DEVICE_FUNC 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_DEVICE_FUNC 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_DEVICE_FUNC 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_DEVICE_FUNC 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_DEVICE_FUNC EIGEN_ALWAYS_INLINE TensorUInt128< uint64_t, uint64_t >	operator- (const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
template<std::size_t n, typename T , T a, T... as>
constexpr T	array_get (const numeric_list< T, a, as... > &)
template<typename Array , int... n>
constexpr EIGEN_STRONG_INLINE Array	h_array_reverse (Array arr, numeric_list< int, n... >)
template<typename T , std::size_t N>
constexpr EIGEN_STRONG_INLINE array< T, N >	array_reverse (array< T, N > arr)
template<typename Reducer , typename T , std::size_t N>
EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE auto	array_reduce (const array< T, N > &arr, T identity) -> decltype(h_array_reduce< Reducer, T, N >::run(arr, identity))
template<typename T , std::size_t N>
EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE auto	array_sum (const array< T, N > &arr) -> decltype(array_reduce< sum_op, T, N >(arr, static_cast< T >(0)))
template<typename T , std::size_t N>
EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE auto	array_prod (const array< T, N > &arr) -> decltype(array_reduce< product_op, T, N >(arr, static_cast< T >(1)))
template<typename t >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE t	array_prod (const std::vector< t > &a)
template<typename Op , typename A , typename B , std::size_t N, int... n>
constexpr EIGEN_STRONG_INLINE array< decltype(Op::run(A(), B())), N >	h_array_zip (array< A, N > a, array< B, N > b, numeric_list< int, n... >)
template<typename Op , typename A , typename B , std::size_t N>
constexpr EIGEN_STRONG_INLINE array< decltype(Op::run(A(), B())), N >	array_zip (array< A, N > a, array< B, N > b)
template<typename Reducer , typename Op , typename A , typename B , std::size_t N, int... n>
constexpr EIGEN_STRONG_INLINE 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))...))
template<typename Reducer , typename Op , typename A , typename B , std::size_t N>
constexpr EIGEN_STRONG_INLINE 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()))
template<typename Op , typename A , std::size_t N, int... n>
constexpr EIGEN_STRONG_INLINE array< decltype(Op::run(A())), N >	h_array_apply (array< A, N > a, numeric_list< int, n... >)
template<typename Op , typename A , std::size_t N>
constexpr EIGEN_STRONG_INLINE array< decltype(Op::run(A())), N >	array_apply (array< A, N > a)
template<typename Reducer , typename Op , typename A , std::size_t N, int... n>
constexpr EIGEN_STRONG_INLINE 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))...))
template<typename Reducer , typename Op , typename A , std::size_t N>
constexpr EIGEN_STRONG_INLINE 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<int n, typename t >
constexpr array< t, n >	repeat (t v)
template<class InstType , typename ArrType , std::size_t N, bool Reverse = false>
InstType	instantiate_by_c_array (ArrType *arr)
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)
template<typename A , typename B >
void	make_coherent (const A &a, const B &b)
template<typename BinOp , typename A , typename B , typename RefType >
void	make_coherent_expression (CwiseBinaryOp< BinOp, A, B > xpr, const RefType &ref)
template<typename UnaryOp , typename A , typename RefType >
void	make_coherent_expression (const CwiseUnaryOp< UnaryOp, A > &xpr, const RefType &ref)
template<typename UnaryOp , typename A , typename RefType >
void	make_coherent_expression (const CwiseNullaryOp< UnaryOp, A > &, const RefType &)
template<typename BVH , typename Intersector >
bool	intersect_helper (const BVH &tree, Intersector &intersector, typename BVH::Index root)
template<typename T >
T *	fftw_cast (const T *p)
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 CMatrix , typename CINVMatrix >
void	pseudo_inverse (const CMatrix &C, CINVMatrix &CINV)
template<typename TMatrix , typename CMatrix , typename VectorX , typename VectorB , typename VectorF >
void	constrained_cg (const TMatrix &A, const CMatrix &C, VectorX &x, const VectorB &b, const VectorF &f, IterationController &iter)
template<typename VectorType , typename IndexType >
void	sortWithPermutation (VectorType &vec, IndexType &perm, typename IndexType::Scalar &ncut)
	Computes a permutation vector to have a sorted sequence.
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)
template<typename Vector , typename RealScalar >
Vector::Scalar	omega (const Vector &t, const Vector &s, RealScalar angle)
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 >
EIGEN_DONT_INLINE void	minres (const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, Index &iters, typename Dest::RealScalar &tol_error)
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 >
void	covar (Matrix< Scalar, Dynamic, Dynamic > &r, const VectorXi &ipvt, Scalar tol=std::sqrt(NumTraits< Scalar >::epsilon()))
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)
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.
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.
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.
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.
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.
template<typename ArgType , typename ResultType >
void	matrix_exp_compute (const ArgType &arg, ResultType &result, true_type)
template<typename ArgType , typename ResultType >
void	matrix_exp_compute (const ArgType &arg, ResultType &result, false_type)
template<typename MatrixType >
NumTraits< typenameMatrixType::Scalar >::Real	matrix_function_compute_mu (const MatrixType &A)
template<typename Index , typename ListOfClusters >
ListOfClusters::iterator	matrix_function_find_cluster (Index key, ListOfClusters &clusters)
	Find cluster in clusters containing some value.
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.
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.
template<typename VectorType >
void	matrix_function_compute_block_start (const VectorType &clusterSize, VectorType &blockStart)
	Compute start of each block using clusterSize.
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.
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.
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.
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.
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.
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.
template<typename MatrixType >
void	matrix_log_compute_2x2 (const MatrixType &A, MatrixType &result)
	Compute logarithm of 2x2 triangular matrix.
int	matrix_log_get_pade_degree (float normTminusI)
int	matrix_log_get_pade_degree (double normTminusI)
int	matrix_log_get_pade_degree (long double normTminusI)
template<typename MatrixType >
void	matrix_log_compute_pade (MatrixType &result, const MatrixType &T, int degree)
template<typename MatrixType >
void	matrix_log_compute_big (const MatrixType &A, MatrixType &result)
	Compute logarithm of triangular matrices with size > 2.
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_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 >
void	matrix_sqrt_quasi_triangular_solve_auxiliary_equation (MatrixType &X, const MatrixType &A, const MatrixType &B, const MatrixType &C)
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 Scalar >
Scalar	stem_function_exp (Scalar x, int)
	The exponential function (and its derivatives).
template<typename Scalar >
Scalar	stem_function_cos (Scalar x, int n)
	Cosine (and its derivatives).
template<typename Scalar >
Scalar	stem_function_sin (Scalar x, int n)
	Sine (and its derivatives).
template<typename Scalar >
Scalar	stem_function_cosh (Scalar x, int n)
	Hyperbolic cosine (and its derivatives).
template<typename Scalar >
Scalar	stem_function_sinh (Scalar x, int n)
	Hyperbolic sine (and its derivatives).
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)
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)
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)
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 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)
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<typename Scalar >
void	rwupdt (Matrix< Scalar, Dynamic, Dynamic > &r, const Matrix< Scalar, Dynamic, 1 > &w, Matrix< Scalar, Dynamic, 1 > &b, Scalar alpha)
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)
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 Scalar , typename StorageIndex >
void	GetMarketLine (const char *line, StorageIndex &i, StorageIndex &j, Scalar &value)
template<>
void	GetMarketLine (const char *line, int &i, int &j, float &value)
template<>
void	GetMarketLine (const char *line, int &i, int &j, double &value)
template<>
void	GetMarketLine (const char *line, int &i, int &j, std::complex< float > &value)
template<>
void	GetMarketLine (const char *line, int &i, int &j, std::complex< double > &value)
template<typename Scalar , typename StorageIndex >
void	GetMarketLine (const char *line, StorageIndex &i, StorageIndex &j, std::complex< Scalar > &value)
template<typename RealScalar >
void	GetVectorElt (const std::string &line, RealScalar &val)
template<typename RealScalar >
void	GetVectorElt (const std::string &line, std::complex< RealScalar > &val)
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)
template<typename Scalar >
void	putVectorElt (Scalar value, std::ofstream &out)
template<typename Scalar >
void	putVectorElt (std::complex< Scalar > value, std::ofstream &out)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_i0 (const Packet &x)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_i0e (const Packet &x)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_i1 (const Packet &x)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_i1e (const Packet &x)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_j0 (const Packet &x)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_j1 (const Packet &x)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_y0 (const Packet &x)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_y1 (const Packet &x)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_k0 (const Packet &x)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_k0e (const Packet &x)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_k1 (const Packet &x)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_k1e (const Packet &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T	generic_fast_erf_float (const T &a_x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T	flipsign (const T &should_flipsign, const T &x)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double	flipsign< double > (const double &should_flipsign, const double &x)
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float	flipsign< float > (const float &should_flipsign, const float &x)
template<typename T , typename ScalarType >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T	generic_ndtri_gt_exp_neg_two (const T &b)
template<typename T , typename ScalarType >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T	generic_ndtri_lt_exp_neg_two (const T &b, const T &should_flipsign)
template<typename T , typename ScalarType >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	generic_ndtri (const T &a)
template<typename Scalar , IgammaComputationMode mode>
EIGEN_DEVICE_FUNC int	igamma_num_iterations ()
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	plgamma (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pdigamma (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pzeta (const Packet &x, const Packet &q)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	ppolygamma (const Packet &n, const Packet &x)
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)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pndtri (const Packet &a)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet	pigamma (const Packet &a, const Packet &x)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet	pigamma_der_a (const Packet &a, const Packet &x)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet	pgamma_sample_der_alpha (const Packet &alpha, const Packet &sample)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet	pigammac (const Packet &a, const Packet &x)
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet	pbetainc (const Packet &a, const Packet &b, const Packet &x)

Variables
const Scalar &	y
const std::ptrdiff_t	defaultL1CacheSize = EIGEN_SET_DEFAULT_L1_CACHE_SIZE(16*1024)
const std::ptrdiff_t	defaultL2CacheSize = EIGEN_SET_DEFAULT_L2_CACHE_SIZE(512*1024)
const std::ptrdiff_t	defaultL3CacheSize = EIGEN_SET_DEFAULT_L3_CACHE_SIZE(512*1024)
template<typename... Ts>
EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE decltype(reduce< product_op, Ts... >::run((*((Ts *) 0))...)	arg_prod )(Ts... ts)
template<typename... Ts>
constexpr EIGEN_STRONG_INLINE decltype(reduce< sum_op, Ts... >::run((*((Ts *) 0))...)	arg_sum )(Ts... ts)

Typedef Documentation

__attribute__

typedef svfloat32_t PacketXf Eigen::internal::__attribute__((arm_sve_vector_bits(EIGEN_ARM64_SVE_VL)))

IntPtr

typedef std::ptrdiff_t Eigen::internal::IntPtr

Packet16b

typedef eigen_packet_wrapper<__m128i, 1> Eigen::internal::Packet16b

Packet16bf

typedef eigen_packet_wrapper<__m256i, 2> Eigen::internal::Packet16bf

Packet16c

typedef int8x16_t Eigen::internal::Packet16c

Packet16f

typedef __m512 Eigen::internal::Packet16f

Packet16h

typedef eigen_packet_wrapper<__m256i, 1> Eigen::internal::Packet16h

Packet16i

typedef __m512i Eigen::internal::Packet16i

Packet16uc

typedef __vector unsigned char Eigen::internal::Packet16uc

Packet2d

typedef __vector double Eigen::internal::Packet2d

Packet2f

typedef float32x2_t Eigen::internal::Packet2f

Packet2i

typedef int32x2_t Eigen::internal::Packet2i

Packet2l

typedef __vector long long Eigen::internal::Packet2l

Packet2ui

typedef uint32x2_t Eigen::internal::Packet2ui

Packet2ul

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

Packet4bf

typedef eigen_packet_wrapper<uint16x4_t, 19> Eigen::internal::Packet4bf

Packet4bi

typedef __vector __bool int Eigen::internal::Packet4bi

Packet4c

typedef eigen_packet_wrapper<int32_t ,2> Eigen::internal::Packet4c

Packet4d

typedef __m256d Eigen::internal::Packet4d

Packet4f

typedef __vector float Eigen::internal::Packet4f

Packet4i

typedef __vector int Eigen::internal::Packet4i

Packet4s

typedef int16x4_t Eigen::internal::Packet4s

Packet4uc

typedef eigen_packet_wrapper<uint32_t ,5> Eigen::internal::Packet4uc

Packet4ui

typedef __vector unsigned int Eigen::internal::Packet4ui

Packet4us

typedef uint16x4_t Eigen::internal::Packet4us

Packet8bf

typedef eigen_packet_wrapper< __m128i, 3 > Eigen::internal::Packet8bf

Packet8c

typedef int8x8_t Eigen::internal::Packet8c

Packet8d

typedef __m512d Eigen::internal::Packet8d

Packet8f

typedef __m256 Eigen::internal::Packet8f

Packet8h

typedef eigen_packet_wrapper<__m128i, 2> Eigen::internal::Packet8h

Packet8i

typedef __vector short int Eigen::internal::Packet8i

Packet8s

typedef int16x8_t Eigen::internal::Packet8s

Packet8uc

typedef uint8x8_t Eigen::internal::Packet8uc

Packet8us

typedef uint16x8_t Eigen::internal::Packet8us

SsePrefetchPtrType

typedef const char* Eigen::internal::SsePrefetchPtrType

UIntPtr

typedef std::size_t Eigen::internal::UIntPtr

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
meta_floor_log2_terminate
meta_floor_log2_move_up
meta_floor_log2_move_down
meta_floor_log2_bogus

anonymous enum

anonymous enum

Enumerator
SDP_AsScalarProduct
SDP_AsCwiseProduct

anonymous enum

anonymous enum

Enumerator
SVA_RuntimeSwitch
SVA_Inner
SVA_Outer

anonymous enum

anonymous enum

Enumerator
LUNoMarker

anonymous enum

anonymous enum

Enumerator
emptyIdxLU

anonymous enum

anonymous enum

Enumerator
PreconditionIfMoreColsThanRows
PreconditionIfMoreRowsThanCols

anonymous enum

anonymous enum

Enumerator
ShardByRow
ShardByCol

anonymous enum

anonymous enum

Enumerator
Rhs
Lhs

ComparisonName

enum Eigen::internal::ComparisonName

Enumerator
cmp_EQ
cmp_LT
cmp_LE
cmp_UNORD
cmp_NEQ
cmp_GT
cmp_GE

GEBPPacketSizeType

enum Eigen::internal::GEBPPacketSizeType

Enumerator
GEBPPacketFull
GEBPPacketHalf
GEBPPacketQuarter

GEMVPacketSizeType

enum Eigen::internal::GEMVPacketSizeType

Enumerator
GEMVPacketFull
GEMVPacketHalf
GEMVPacketQuarter

IgammaComputationMode

enum Eigen::internal::IgammaComputationMode

Enumerator
VALUE
DERIVATIVE
SAMPLE_DERIVATIVE

MemType

enum Eigen::internal::MemType

Enumerator
LUSUP
UCOL
LSUB
USUB
LLVL
ULVL

PermPermProduct_t

enum Eigen::internal::PermPermProduct_t

Enumerator
PermPermProduct

SignMatrix

enum Eigen::internal::SignMatrix

Enumerator
PositiveSemiDef
NegativeSemiDef
ZeroSign
Indefinite

TensorBlockKind

enum Eigen::internal::TensorBlockKind

Enumerator
kExpr
kView
kMaterializedInScratch
kMaterializedInOutput

TensorBlockShapeType

enum class Eigen::internal::TensorBlockShapeType

strong

Enumerator
kUniformAllDims
kSkewedInnerDims

TiledEvaluation

enum Eigen::internal::TiledEvaluation

Enumerator
Off
On

Function Documentation

__UNPACK_TYPE__()

template<typename Packet >

EIGEN_STRONG_INLINE Eigen::internal::__UNPACK_TYPE__

(

Packet

)

const &

absolute_split()

template<typename Packet >

EIGEN_STRONG_INLINE void Eigen::internal::absolute_split	(	const Packet &	x,
		Packet &	n,
		Packet &	r
	)

aligned_delete()

template<typename T >

EIGEN_DEVICE_FUNC void Eigen::internal::aligned_delete ( T *  ptr, std::size_t  size  )

inline

aligned_free()

EIGEN_DEVICE_FUNC void Eigen::internal::aligned_free ( void *  ptr )

inline

aligned_malloc()

EIGEN_DEVICE_FUNC void * Eigen::internal::aligned_malloc ( std::size_t  size )

inline

aligned_new()

template<typename T >

EIGEN_DEVICE_FUNC T * Eigen::internal::aligned_new ( std::size_t  size )

inline

aligned_realloc()

void * Eigen::internal::aligned_realloc ( void *  ptr, std::size_t  new_size, std::size_t  old_size  )

inline

amd_flip()

template<typename T >

T Eigen::internal::amd_flip ( const T &  i )

inline

amd_mark()

template<typename T0 , typename T1 >

void Eigen::internal::amd_mark ( const T0 *  w, const T1 &  j  )

inline

amd_marked()

template<typename T0 , typename T1 >

bool Eigen::internal::amd_marked ( const T0 *  w, const T1 &  j  )

inline

amd_unflip()

template<typename T >

T Eigen::internal::amd_unflip ( const T &  i )

inline

apply_bit_op()

template<typename T , typename Bits , typename Func >

T Eigen::internal::apply_bit_op	(	Bits	a,
		Bits	b,
		Func	f
	)

apply_block_householder_on_the_left()

template<typename MatrixType , typename VectorsType , typename CoeffsType >

void Eigen::internal::apply_block_householder_on_the_left	(	MatrixType &	mat,
		const VectorsType &	vectors,
		const CoeffsType &	hCoeffs,
		bool	forward
	)

apply_rotation_in_the_plane()

template<typename VectorX , typename VectorY , typename OtherScalar >

EIGEN_DEVICE_FUNC void Eigen::internal::apply_rotation_in_the_plane ( DenseBase< VectorX > &  xpr_x, DenseBase< VectorY > &  xpr_y, const JacobiRotation< OtherScalar > &  j  )

protected

\jacobi_module Applies the clock wise 2D rotation j to the set of 2D vectors of coordinates x and y:

See also

MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()

array_apply()

template<typename Op , typename A , std::size_t N>

constexpr EIGEN_STRONG_INLINE array< decltype(Op::run(A())), N > Eigen::internal::array_apply ( array< A, N >  a )

constexpr

array_apply_and_reduce()

template<typename Reducer , typename Op , typename A , std::size_t N>

constexpr EIGEN_STRONG_INLINE auto Eigen::internal::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()))

constexpr

array_get() [1/8]

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

const Index Eigen::internal::array_get

(

const DimensionList< Index, Rank > &

)

array_get() [2/8]

template<std::size_t n, typename T , T a, T... as>

constexpr T Eigen::internal::array_get ( const numeric_list< T, a, as... > &  )

constexpr

array_get() [3/8]

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

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t Eigen::internal::array_get

(

const Sizes< Indices... > &

)

array_get() [4/8]

template<std::ptrdiff_t n>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t Eigen::internal::array_get

(

const Sizes<> &

)

array_get() [5/8]

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

const Index Eigen::internal::array_get

(

DimensionList< Index, Rank > &

)

array_get() [6/8]

template<std::size_t I_, class T >

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

inlineconstexpr

array_get() [7/8]

template<std::size_t I_, class T >

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

inlineconstexpr

array_get() [8/8]

template<std::size_t I_, class T >

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

inlineconstexpr

array_prod() [1/3]

template<typename T , std::size_t N>

EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE auto Eigen::internal::array_prod ( const array< T, N > &  arr ) -> decltype(array_reduce<product_op, T, N>(arr, static_cast<T>(1)))

constexpr

array_prod() [2/3]

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

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t Eigen::internal::array_prod

(

const Sizes< Indices... > &

)

array_prod() [3/3]

template<typename t >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE t Eigen::internal::array_prod

(

const std::vector< t > &

a

)

array_reduce()

template<typename Reducer , typename T , std::size_t N>

EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE auto Eigen::internal::array_reduce ( const array< T, N > &  arr, T  identity  ) -> decltype(h_array_reduce<Reducer, T, N>::run(arr, identity))

constexpr

array_reverse()

template<typename T , std::size_t N>

constexpr EIGEN_STRONG_INLINE array< T, N > Eigen::internal::array_reverse ( array< T, N >  arr )

constexpr

array_sum()

template<typename T , std::size_t N>

EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE auto Eigen::internal::array_sum ( const array< T, N > &  arr ) -> decltype(array_reduce<sum_op, T, N>(arr, static_cast<T>(0)))

constexpr

array_zip()

template<typename Op , typename A , typename B , std::size_t N>

constexpr EIGEN_STRONG_INLINE array< decltype(Op::run(A(), B())), N > Eigen::internal::array_zip ( array< A, N >  a, array< B, N >  b  )

constexpr

array_zip_and_reduce()

template<typename Reducer , typename Op , typename A , typename B , std::size_t N>

constexpr EIGEN_STRONG_INLINE auto Eigen::internal::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()))

constexpr

assign_sparse_to_sparse()

template<typename DstXprType , typename SrcXprType >

void Eigen::internal::assign_sparse_to_sparse	(	DstXprType &	dst,
		const SrcXprType &	src
	)

asSluMatrix()

template<typename MatrixType >

SluMatrix Eigen::internal::asSluMatrix

(

MatrixType &

mat

)

band()

template<typename Packet >

EIGEN_ALWAYS_INLINE void Eigen::internal::band	(	PacketBlock< Packet, 4 > &	acc,
		const Packet &	pMask
	)

bcouple() [1/2]

template<typename Packet , typename Packetc >

EIGEN_ALWAYS_INLINE void Eigen::internal::bcouple	(	PacketBlock< Packet, 1 > &	taccReal,
		PacketBlock< Packet, 1 > &	taccImag,
		PacketBlock< Packetc, 2 > &	tRes,
		PacketBlock< Packetc, 1 > &	acc1,
		PacketBlock< Packetc, 1 > &	acc2
	)

bcouple() [2/2]

template<typename Packet , typename Packetc >

EIGEN_ALWAYS_INLINE void Eigen::internal::bcouple	(	PacketBlock< Packet, 4 > &	taccReal,
		PacketBlock< Packet, 4 > &	taccImag,
		PacketBlock< Packetc, 8 > &	tRes,
		PacketBlock< Packetc, 4 > &	acc1,
		PacketBlock< Packetc, 4 > &	acc2
	)

bcouple_common() [1/2]

template<typename Packet , typename Packetc >

EIGEN_ALWAYS_INLINE void Eigen::internal::bcouple_common	(	PacketBlock< Packet, 1 > &	taccReal,
		PacketBlock< Packet, 1 > &	taccImag,
		PacketBlock< Packetc, 1 > &	acc1,
		PacketBlock< Packetc, 1 > &	acc2
	)

bcouple_common() [2/2]

template<typename Packet , typename Packetc >

EIGEN_ALWAYS_INLINE void Eigen::internal::bcouple_common	(	PacketBlock< Packet, 4 > &	taccReal,
		PacketBlock< Packet, 4 > &	taccImag,
		PacketBlock< Packetc, 4 > &	acc1,
		PacketBlock< Packetc, 4 > &	acc2
	)

bcouple_common< Packet2d, Packet1cd >() [1/2]

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::bcouple_common< Packet2d, Packet1cd >	(	PacketBlock< Packet2d, 1 > &	taccReal,
		PacketBlock< Packet2d, 1 > &	taccImag,
		PacketBlock< Packet1cd, 1 > &	acc1,
		PacketBlock< Packet1cd, 1 > &	acc2
	)

bcouple_common< Packet2d, Packet1cd >() [2/2]

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::bcouple_common< Packet2d, Packet1cd >	(	PacketBlock< Packet2d, 4 > &	taccReal,
		PacketBlock< Packet2d, 4 > &	taccImag,
		PacketBlock< Packet1cd, 4 > &	acc1,
		PacketBlock< Packet1cd, 4 > &	acc2
	)

Bf16ToF32() [1/3]

EIGEN_STRONG_INLINE Packet16f Eigen::internal::Bf16ToF32

(

const Packet16bf &

a

)

Bf16ToF32() [2/3]

EIGEN_STRONG_INLINE Packet4f Eigen::internal::Bf16ToF32

(

const Packet4bf &

p

)

Bf16ToF32() [3/3]

EIGEN_STRONG_INLINE Packet8f Eigen::internal::Bf16ToF32

(

const Packet8bf &

a

)

Bf16ToF32Even()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::Bf16ToF32Even

(

const Packet8bf &

bf

)

Bf16ToF32Odd()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::Bf16ToF32Odd

(

const Packet8bf &

bf

)

bicgstab()

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

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

biteq()

template<typename T >

bool Eigen::internal::biteq	(	T	a,
		T	b
	)

bits()

template<typename T >

Map< const Array< unsigned char, sizeof(T), 1 > > Eigen::internal::bits

(

const T &

x

)

bload() [1/3]

template<typename DataMapper , typename Packet , typename Index , const Index accCols, int N, int StorageOrder>

EIGEN_ALWAYS_INLINE void Eigen::internal::bload	(	PacketBlock< Packet, 2 > &	acc,
		const DataMapper &	res,
		Index	row,
		Index	col
	)

bload() [2/3]

template<typename DataMapper , typename Packet , typename Index , const Index accCols, int N, int StorageOrder>

EIGEN_ALWAYS_INLINE void Eigen::internal::bload	(	PacketBlock< Packet, 4 > &	acc,
		const DataMapper &	res,
		Index	row,
		Index	col
	)

bload() [3/3]

template<typename DataMapper , typename Packet , typename Index , const Index accCols, int N, int StorageOrder>

EIGEN_ALWAYS_INLINE void Eigen::internal::bload	(	PacketBlock< Packet, 8 > &	acc,
		const DataMapper &	res,
		Index	row,
		Index	col
	)

BlockedInPlaceTranspose()

template<typename MatrixType , Index Alignment>

void Eigen::internal::BlockedInPlaceTranspose ( MatrixType &  m )

protected

blueNorm_impl()

template<typename Derived >

NumTraits< typenametraits< Derived >::Scalar >::Real Eigen::internal::blueNorm_impl ( const EigenBase< Derived > &  _vec )

inline

bmask()

template<typename Packet >

EIGEN_ALWAYS_INLINE Packet Eigen::internal::bmask

(

const int

remaining_rows

)

bmask< Packet2d >()

template<>

EIGEN_ALWAYS_INLINE Packet2d Eigen::internal::bmask< Packet2d >

(

const int

remaining_rows

)

bruteforce_det3_helper()

template<typename Derived >

EIGEN_DEVICE_FUNC const Derived::Scalar Eigen::internal::bruteforce_det3_helper ( const MatrixBase< Derived > &  matrix, int  a, int  b, int  c  )

inline

bscale() [1/3]

template<typename Packet >

EIGEN_ALWAYS_INLINE void Eigen::internal::bscale	(	PacketBlock< Packet, 1 > &	acc,
		PacketBlock< Packet, 1 > &	accZ,
		const Packet &	pAlpha
	)

bscale() [2/3]

template<typename Packet >

EIGEN_ALWAYS_INLINE void Eigen::internal::bscale	(	PacketBlock< Packet, 4 > &	acc,
		PacketBlock< Packet, 4 > &	accZ,
		const Packet &	pAlpha
	)

bscale() [3/3]

template<typename Packet >

EIGEN_ALWAYS_INLINE void Eigen::internal::bscale	(	PacketBlock< Packet, 4 > &	acc,
		PacketBlock< Packet, 4 > &	accZ,
		const Packet &	pAlpha,
		const Packet &	pMask
	)

bscalec() [1/2]

template<typename Packet >

EIGEN_ALWAYS_INLINE void Eigen::internal::bscalec	(	PacketBlock< Packet, 4 > &	aReal,
		PacketBlock< Packet, 4 > &	aImag,
		const Packet &	bReal,
		const Packet &	bImag,
		PacketBlock< Packet, 4 > &	cReal,
		PacketBlock< Packet, 4 > &	cImag,
		const Packet &	pMask
	)

bscalec() [2/2]

template<typename Packet , int N>

EIGEN_ALWAYS_INLINE void Eigen::internal::bscalec	(	PacketBlock< Packet, N > &	aReal,
		PacketBlock< Packet, N > &	aImag,
		const Packet &	bReal,
		const Packet &	bImag,
		PacketBlock< Packet, N > &	cReal,
		PacketBlock< Packet, N > &	cImag
	)

bscalec_common() [1/2]

template<typename Packet >

EIGEN_ALWAYS_INLINE void Eigen::internal::bscalec_common	(	PacketBlock< Packet, 1 > &	acc,
		PacketBlock< Packet, 1 > &	accZ,
		const Packet &	pAlpha
	)

bscalec_common() [2/2]

template<typename Packet >

EIGEN_ALWAYS_INLINE void Eigen::internal::bscalec_common	(	PacketBlock< Packet, 4 > &	acc,
		PacketBlock< Packet, 4 > &	accZ,
		const Packet &	pAlpha
	)

bsetzero() [1/2]

template<typename Scalar , typename Packet >

EIGEN_ALWAYS_INLINE void Eigen::internal::bsetzero

(

PacketBlock< Packet, 1 > &

acc

)

bsetzero() [2/2]

template<typename Scalar , typename Packet >

EIGEN_ALWAYS_INLINE void Eigen::internal::bsetzero

(

PacketBlock< Packet, 4 > &

acc

)

bsetzeroMMA()

template<typename Scalar , typename Packet >

EIGEN_ALWAYS_INLINE void Eigen::internal::bsetzeroMMA

(

__vector_quad *

acc

)

c_to_fortran_numbering()

template<typename MatrixType >

void Eigen::internal::c_to_fortran_numbering

(

MatrixType &

mat

)

call_assignment() [1/6]

template<typename Dst , typename Src >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::call_assignment	(	const Dst &	dst,
		const Src &	src
	)

call_assignment() [2/6]

template<typename Dst , template< typename > class StorageBase, typename Src , typename Func >

EIGEN_DEVICE_FUNC void Eigen::internal::call_assignment	(	const NoAlias< Dst, StorageBase > &	dst,
		const Src &	src,
		const Func &	func
	)

call_assignment() [3/6]

template<typename Dst , typename Src >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::call_assignment	(	Dst &	dst,
		const Src &	src
	)

call_assignment() [4/6]

template<typename Dst , typename Src , typename Func >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::call_assignment	(	Dst &	dst,
		const Src &	src,
		const Func &	func,
		typename enable_if< evaluator_assume_aliasing< Src >::value, void * >::type	= 0
	)

call_assignment() [5/6]

template<typename Dst , typename Src , typename Func >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::call_assignment	(	Dst &	dst,
		const Src &	src,
		const Func &	func,
		typename enable_if<!evaluator_assume_aliasing< Src >::value, void * >::type	= 0
	)

call_assignment() [6/6]

template<typename Dst , template< typename > class StorageBase, typename Src , typename Func >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::call_assignment	(	NoAlias< Dst, StorageBase > &	dst,
		const Src &	src,
		const Func &	func
	)

call_assignment_no_alias() [1/2]

template<typename Dst , typename Src >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::call_assignment_no_alias	(	Dst &	dst,
		const Src &	src
	)

call_assignment_no_alias() [2/2]

template<typename Dst , typename Src , typename Func >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::call_assignment_no_alias	(	Dst &	dst,
		const Src &	src,
		const Func &	func
	)

call_assignment_no_alias_no_transpose() [1/2]

template<typename Dst , typename Src >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::call_assignment_no_alias_no_transpose	(	Dst &	dst,
		const Src &	src
	)

call_assignment_no_alias_no_transpose() [2/2]

template<typename Dst , typename Src , typename Func >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::call_assignment_no_alias_no_transpose	(	Dst &	dst,
		const Src &	src,
		const Func &	func
	)

call_dense_assignment_loop() [1/3]

template<typename DstXprType >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::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
	)

call_dense_assignment_loop() [2/3]

template<typename DstXprType , typename SrcXprType >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::call_dense_assignment_loop	(	DstXprType &	dst,
		const SrcXprType &	src
	)

call_dense_assignment_loop() [3/3]

template<typename DstXprType , typename SrcXprType , typename Functor >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::call_dense_assignment_loop	(	DstXprType &	dst,
		const SrcXprType &	src,
		const Functor &	func
	)

call_restricted_packet_assignment()

template<typename Dst , template< typename > class StorageBase, typename Src , typename Func >

EIGEN_DEVICE_FUNC void Eigen::internal::call_restricted_packet_assignment	(	const NoAlias< Dst, StorageBase > &	dst,
		const Src &	src,
		const Func &	func
	)

call_restricted_packet_assignment_no_alias()

template<typename Dst , typename Src , typename Func >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::call_restricted_packet_assignment_no_alias	(	Dst &	dst,
		const Src &	src,
		const Func &	func
	)

call_triangular_assignment_loop() [1/2]

template<int Mode, bool SetOpposite, typename DstXprType , typename SrcXprType >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::call_triangular_assignment_loop	(	DstXprType &	dst,
		const SrcXprType &	src
	)

call_triangular_assignment_loop() [2/2]

template<int Mode, bool SetOpposite, typename DstXprType , typename SrcXprType , typename Functor >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::call_triangular_assignment_loop	(	DstXprType &	dst,
		const SrcXprType &	src,
		const Functor &	func
	)

cast() [1/3]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::cast

(

const AnnoyingScalar &

x

)

cast() [2/3]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::cast

(

const AnnoyingScalar &

x

)

cast() [3/3]

template<typename OldType , typename NewType >

EIGEN_DEVICE_FUNC NewType Eigen::internal::cast ( const OldType &  x )

inline

cat256()

EIGEN_STRONG_INLINE Packet16f Eigen::internal::cat256	(	Packet8f	a,
		Packet8f	b
	)

check_for_aliasing()

template<typename Dst , typename Src >

void Eigen::internal::check_for_aliasing	(	const Dst &	dst,
		const Src &	src
	)

check_size_for_overflow()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void Eigen::internal::check_size_for_overflow

(

std::size_t

size

)

check_static_allocation_size()

template<typename T , int Size>

EIGEN_DEVICE_FUNC void Eigen::internal::check_static_allocation_size

(

)

check_that_malloc_is_allowed()

EIGEN_DEVICE_FUNC void Eigen::internal::check_that_malloc_is_allowed ( )

inline

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
	)

cm_factorize_p()

template<typename _StorageIndex >

int Eigen::internal::cm_factorize_p ( cholmod_sparse *  A, double  beta[2], _StorageIndex *  fset, std::size_t  fsize, cholmod_factor *  L, cholmod_common &  Common  )

inline

cm_factorize_p< SuiteSparse_long >()

template<>

int Eigen::internal::cm_factorize_p< SuiteSparse_long > ( cholmod_sparse *  A, double  beta[2], SuiteSparse_long *  fset, std::size_t  fsize, cholmod_factor *  L, cholmod_common &  Common  )

inline

cm_solve()

template<typename _StorageIndex >

cholmod_dense * Eigen::internal::cm_solve ( int  sys, cholmod_factor &  L, cholmod_dense &  B, cholmod_common &  Common  )

inline

cm_solve< SuiteSparse_long >()

template<>

cholmod_dense * Eigen::internal::cm_solve< SuiteSparse_long > ( int  sys, cholmod_factor &  L, cholmod_dense &  B, cholmod_common &  Common  )

inline

cm_spsolve()

template<typename _StorageIndex >

cholmod_sparse * Eigen::internal::cm_spsolve ( int  sys, cholmod_factor &  L, cholmod_sparse &  B, cholmod_common &  Common  )

inline

cm_spsolve< SuiteSparse_long >()

template<>

cholmod_sparse * Eigen::internal::cm_spsolve< SuiteSparse_long > ( int  sys, cholmod_factor &  L, cholmod_sparse &  B, cholmod_common &  Common  )

inline

cofactor_3x3()

template<typename MatrixType , int i, int j>

EIGEN_DEVICE_FUNC MatrixType::Scalar Eigen::internal::cofactor_3x3 ( const MatrixType &  m )

inline

cofactor_4x4()

template<typename MatrixType , int i, int j>

EIGEN_DEVICE_FUNC MatrixType::Scalar Eigen::internal::cofactor_4x4 ( const MatrixType &  matrix )

inline

coletree()

template<typename MatrixType , typename IndexVector >

int Eigen::internal::coletree	(	const MatrixType &	mat,
		IndexVector &	parent,
		IndexVector &	firstRowElt,
		typename MatrixType::StorageIndex *	perm = 0
	)

Compute the column elimination tree of a sparse matrix

Parameters

mat	The matrix in column-major format.
parent	The elimination tree
firstRowElt	The column index of the first element in each row
perm	The permutation to apply to the column of mat

combine_scalar_factors() [1/2]

template<typename ResScalar , typename Lhs , typename Rhs >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE ResScalar Eigen::internal::combine_scalar_factors	(	const Lhs &	lhs,
		const Rhs &	rhs
	)

combine_scalar_factors() [2/2]

template<typename ResScalar , typename Lhs , typename Rhs >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE ResScalar Eigen::internal::combine_scalar_factors	(	const ResScalar &	alpha,
		const Lhs &	lhs,
		const Rhs &	rhs
	)

complex_log()

template<typename T >

EIGEN_DEVICE_FUNC std::complex< T > Eigen::internal::complex_log

(

const std::complex< T > &

z

)

complex_rsqrt()

template<typename T >

EIGEN_DEVICE_FUNC std::complex< T > Eigen::internal::complex_rsqrt

(

const std::complex< T > &

a_x

)

complex_sqrt()

template<typename T >

EIGEN_DEVICE_FUNC std::complex< T > Eigen::internal::complex_sqrt

(

const std::complex< T > &

a_x

)

compute_inverse_size2_helper()

template<typename MatrixType , typename ResultType >

EIGEN_DEVICE_FUNC void Eigen::internal::compute_inverse_size2_helper ( const MatrixType &  matrix, const typename ResultType::Scalar &  invdet, ResultType &  result  )

inline

compute_inverse_size3_helper()

template<typename MatrixType , typename ResultType >

EIGEN_DEVICE_FUNC void Eigen::internal::compute_inverse_size3_helper ( const MatrixType &  matrix, const typename ResultType::Scalar &  invdet, const Matrix< typename ResultType::Scalar, 3, 1 > &  cofactors_col0, ResultType &  result  )

inline

computeFromTridiagonal_impl()

template<typename MatrixType , typename DiagType , typename SubDiagType >

EIGEN_DEVICE_FUNC ComputationInfo Eigen::internal::computeFromTridiagonal_impl	(	DiagType &	diag,
		SubDiagType &	subdiag,
		const Index	maxIterations,
		bool	computeEigenvectors,
		MatrixType &	eivec
	)

computeProductBlockingSizes() [1/2]

template<typename LhsScalar , typename RhsScalar , int KcFactor, typename Index >

void Eigen::internal::computeProductBlockingSizes	(	Index &	k,
		Index &	m,
		Index &	n,
		Index	num_threads = 1
	)

Computes the blocking parameters for a m x k times k x n matrix product.

Parameters

[in,out]	k	Input: the third dimension of the product. Output: the blocking size along the same dimension.
[in,out]	m	Input: the number of rows of the left hand side. Output: the blocking size along the same dimension.
[in,out]	n	Input: the number of columns of the right hand side. Output: the blocking size along the same dimension.

Given a m x k times k x n matrix product of scalar types LhsScalar and RhsScalar, this function computes the blocking size parameters along the respective dimensions for matrix products and related algorithms.

The blocking size parameters may be evaluated:

• either by a heuristic based on cache sizes;
• or using fixed prescribed values (for testing purposes).

See also

setCpuCacheSizes

computeProductBlockingSizes() [2/2]

template<typename LhsScalar , typename RhsScalar , typename Index >

void Eigen::internal::computeProductBlockingSizes ( Index &  k, Index &  m, Index &  n, Index  num_threads = 1  )

inline

conditional_aligned_delete()

template<typename T , bool Align>

EIGEN_DEVICE_FUNC void Eigen::internal::conditional_aligned_delete ( T *  ptr, std::size_t  size  )

inline

conditional_aligned_delete_auto()

template<typename T , bool Align>

EIGEN_DEVICE_FUNC void Eigen::internal::conditional_aligned_delete_auto ( T *  ptr, std::size_t  size  )

inline

conditional_aligned_free()

template<bool Align>

EIGEN_DEVICE_FUNC void Eigen::internal::conditional_aligned_free ( void *  ptr )

inline

conditional_aligned_free< false >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::conditional_aligned_free< false > ( void *  ptr )

inline

conditional_aligned_malloc()

template<bool Align>

EIGEN_DEVICE_FUNC void * Eigen::internal::conditional_aligned_malloc ( std::size_t  size )

inline

conditional_aligned_malloc< false >()

template<>

EIGEN_DEVICE_FUNC void * Eigen::internal::conditional_aligned_malloc< false > ( std::size_t  size )

inline

conditional_aligned_new()

template<typename T , bool Align>

EIGEN_DEVICE_FUNC T * Eigen::internal::conditional_aligned_new ( std::size_t  size )

inline

conditional_aligned_new_auto()

template<typename T , bool Align>

EIGEN_DEVICE_FUNC T * Eigen::internal::conditional_aligned_new_auto ( std::size_t  size )

inline

conditional_aligned_realloc()

template<bool Align>

void * Eigen::internal::conditional_aligned_realloc ( void *  ptr, std::size_t  new_size, std::size_t  old_size  )

inline

conditional_aligned_realloc< false >()

template<>

void * Eigen::internal::conditional_aligned_realloc< false > ( void *  ptr, std::size_t  new_size, std::size_t    )

inline

conditional_aligned_realloc_new()

template<typename T , bool Align>

EIGEN_DEVICE_FUNC T * Eigen::internal::conditional_aligned_realloc_new ( T *  pts, std::size_t  new_size, std::size_t  old_size  )

inline

conditional_aligned_realloc_new_auto()

template<typename T , bool Align>

T * Eigen::internal::conditional_aligned_realloc_new_auto ( T *  pts, std::size_t  new_size, std::size_t  old_size  )

inline

conjugate_gradient()

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

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

const_cast_ptr()

template<typename T >

EIGEN_DEVICE_FUNC T * Eigen::internal::const_cast_ptr ( const T *  ptr )

inline

construct_elements_of_array()

template<typename T >

EIGEN_DEVICE_FUNC T * Eigen::internal::construct_elements_of_array ( T *  ptr, std::size_t  size  )

inline

convert_index()

template<typename IndexDest , typename IndexSrc >

EIGEN_DEVICE_FUNC IndexDest Eigen::internal::convert_index ( const IndexSrc &  idx )

inline

copy_bool()

bool Eigen::internal::copy_bool ( bool  b )

inline

covar()

template<typename Scalar >

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

cs_tdfs()

template<typename StorageIndex >

StorageIndex Eigen::internal::cs_tdfs	(	StorageIndex	j,
		StorageIndex	k,
		StorageIndex *	head,
		const StorageIndex *	next,
		StorageIndex *	post,
		StorageIndex *	stack
	)

destruct_elements_of_array()

template<typename T >

EIGEN_DEVICE_FUNC void Eigen::internal::destruct_elements_of_array ( T *  ptr, std::size_t  size  )

inline

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
	)

doubleword_reciprocal()

template<typename Packet >

void Eigen::internal::doubleword_reciprocal	(	const Packet &	x,
		Packet &	recip_hi,
		Packet &	recip_lo
	)

EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE() [1/6]

Eigen::internal::EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE	(	add_assign_op	,
		scalar_difference_op	,
		sub_assign_op
	)

EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE() [2/6]

Eigen::internal::EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE	(	add_assign_op	,
		scalar_sum_op	,
		add_assign_op
	)

EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE() [3/6]

Eigen::internal::EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE	(	assign_op	,
		scalar_difference_op	,
		sub_assign_op
	)

EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE() [4/6]

Eigen::internal::EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE	(	assign_op	,
		scalar_sum_op	,
		add_assign_op
	)

EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE() [5/6]

Eigen::internal::EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE	(	sub_assign_op	,
		scalar_difference_op	,
		add_assign_op
	)

EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE() [6/6]

Eigen::internal::EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE	(	sub_assign_op	,
		scalar_sum_op	,
		sub_assign_op
	)

EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT() [1/6]

Eigen::internal::EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT	(	add_assign_op	,
		scalar_difference_op	,
		sub_assign_op
	)

EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT() [2/6]

Eigen::internal::EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT	(	add_assign_op	,
		scalar_sum_op	,
		add_assign_op
	)

EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT() [3/6]

Eigen::internal::EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT	(	assign_op	,
		scalar_difference_op	,
		sub_assign_op
	)

EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT() [4/6]

Eigen::internal::EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT	(	assign_op	,
		scalar_sum_op	,
		add_assign_op
	)

EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT() [5/6]

Eigen::internal::EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT	(	sub_assign_op	,
		scalar_difference_op	,
		add_assign_op
	)

EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT() [6/6]

Eigen::internal::EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT	(	sub_assign_op	,
		scalar_sum_op	,
		sub_assign_op
	)

EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR() [1/4]

Eigen::internal::EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR ( maxCoeff  , (Size-1) *NumTraits< Scalar >::AddCost  , 1  , internal::scalar_max_op    )

protected

EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR() [2/4]

Eigen::internal::EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR ( minCoeff  , (Size-1) *NumTraits< Scalar >::AddCost  , 1  , internal::scalar_min_op    )

protected

EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR() [3/4]

Eigen::internal::EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR ( prod  , (Size-1) *NumTraits< Scalar >::MulCost  , 1  , internal::scalar_product_op    )

protected

EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR() [4/4]

Eigen::internal::EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR ( sum  , (Size-1) *NumTraits< Scalar >::AddCost  , 1  , internal::scalar_sum_op    )

protected

EIGEN_MATHFUNC_RETVAL() [1/2]

template<typename Scalar >

Eigen::internal::EIGEN_MATHFUNC_RETVAL ( random  , Scalar    )

inline

EIGEN_MATHFUNC_RETVAL() [2/2]

template<typename Scalar >

Eigen::internal::EIGEN_MATHFUNC_RETVAL ( random  , Scalar    ) const &

inline

EIGEN_MEMBER_FUNCTOR() [1/7]

Eigen::internal::EIGEN_MEMBER_FUNCTOR ( all  , (Size-1) *NumTraits< Scalar >::AddCost    )

protected

EIGEN_MEMBER_FUNCTOR() [2/7]

Eigen::internal::EIGEN_MEMBER_FUNCTOR ( any  , (Size-1) *NumTraits< Scalar >::AddCost    )

protected

EIGEN_MEMBER_FUNCTOR() [3/7]

Eigen::internal::EIGEN_MEMBER_FUNCTOR ( blueNorm  , (Size+5) *NumTraits< Scalar >::MulCost+(Size-1) *NumTraits< Scalar >::AddCost    )

protected

EIGEN_MEMBER_FUNCTOR() [4/7]

Eigen::internal::EIGEN_MEMBER_FUNCTOR ( count  , (Size-1) *NumTraits< Scalar >::AddCost    )

protected

EIGEN_MEMBER_FUNCTOR() [5/7]

Eigen::internal::EIGEN_MEMBER_FUNCTOR ( hypotNorm  , (Size-1) *functor_traits< scalar_hypot_op< Scalar > >::Cost    )

protected

EIGEN_MEMBER_FUNCTOR() [6/7]

Eigen::internal::EIGEN_MEMBER_FUNCTOR ( norm  , (Size+5) *NumTraits< Scalar >::MulCost+(Size-1) *NumTraits< Scalar >::AddCost    )

protected

EIGEN_MEMBER_FUNCTOR() [7/7]

Eigen::internal::EIGEN_MEMBER_FUNCTOR ( stableNorm  , (Size+5) *NumTraits< Scalar >::MulCost+(Size-1) *NumTraits< Scalar >::AddCost    )

protected

eigen_pastix() [1/4]

void Eigen::internal::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  )

inline

eigen_pastix() [2/4]

void Eigen::internal::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  )

inline

eigen_pastix() [3/4]

void Eigen::internal::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  )

inline

eigen_pastix() [4/4]

void Eigen::internal::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  )

inline

etree_find()

template<typename Index , typename IndexVector >

Index Eigen::internal::etree_find	(	Index	i,
		IndexVector &	pp
	)

Find the root of the tree/set containing the vertex i : Use Path halving

eval_expr_given_size() [1/3]

template<typename Derived >

Index Eigen::internal::eval_expr_given_size	(	const symbolic::BaseExpr< Derived > &	x,
		Index	size
	)

eval_expr_given_size() [2/3]

template<int N>

FixedInt< N > Eigen::internal::eval_expr_given_size	(	FixedInt< N >	x,
		Index
	)

eval_expr_given_size() [3/3]

Index Eigen::internal::eval_expr_given_size ( Index  x, Index    )

inline

evaluateProductBlockingSizesHeuristic()

template<typename LhsScalar , typename RhsScalar , int KcFactor, typename Index >

void Eigen::internal::evaluateProductBlockingSizesHeuristic	(	Index &	k,
		Index &	m,
		Index &	n,
		Index	num_threads = 1
	)

extract128()

template<int I_>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::extract128

(

Packet8d

x

)

extract256()

template<int I_>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::extract256

(

Packet16f

x

)

extract_data()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T::Scalar * Eigen::internal::extract_data

(

const T &

m

)

F32MaskToBf16Mask()

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::F32MaskToBf16Mask

(

const Packet4f &

p

)

F32ToBf16() [1/5]

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::F32ToBf16

(

const Packet16f &

a

)

F32ToBf16() [2/5]

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::F32ToBf16

(

const Packet4f &

p

)

F32ToBf16() [3/5]

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::F32ToBf16

(

const Packet8f &

a

)

F32ToBf16() [4/5]

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::F32ToBf16	(	Packet4f	even,
		Packet4f	odd
	)

F32ToBf16() [5/5]

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::F32ToBf16

(

Packet4f

p4f

)

F32ToBf16Bool()

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::F32ToBf16Bool	(	Packet4f	even,
		Packet4f	odd
	)

fast_twosum() [1/3]

template<typename Packet >

EIGEN_STRONG_INLINE void Eigen::internal::fast_twosum	(	const Packet &	x,
		const Packet &	y,
		Packet &	s_hi,
		Packet &	s_lo
	)

fast_twosum() [2/3]

template<typename Packet >

EIGEN_STRONG_INLINE void Eigen::internal::fast_twosum	(	const Packet &	x,
		const Packet &	y_hi,
		const Packet &	y_lo,
		Packet &	s_hi,
		Packet &	s_lo
	)

fast_twosum() [3/3]

template<typename Packet >

EIGEN_STRONG_INLINE void Eigen::internal::fast_twosum	(	const Packet &	x_hi,
		const Packet &	x_lo,
		const Packet &	y_hi,
		const Packet &	y_lo,
		Packet &	s_hi,
		Packet &	s_lo
	)

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
	)

fftw_cast() [1/4]

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

inline

fftw_cast() [2/4]

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

inline

fftw_cast() [3/4]

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

inline

fftw_cast() [4/4]

template<typename T >

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

inline

first()

template<typename T >

EIGEN_CONSTEXPR Index Eigen::internal::first

(

const T &

x

)

first_aligned()

template<int Alignment, typename Scalar , typename Index >

EIGEN_DEVICE_FUNC Index Eigen::internal::first_aligned ( const Scalar *  array, Index  size  )

inline

first_default_aligned()

template<typename Scalar , typename Index >

EIGEN_DEVICE_FUNC Index Eigen::internal::first_default_aligned ( const Scalar *  array, Index  size  )

inline

first_multiple()

template<typename Index >

Index Eigen::internal::first_multiple ( Index  size, Index  base  )

inline

flipsign()

template<typename T >

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

flipsign< double >()

template<>

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

flipsign< float >()

template<>

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

float2half() [1/2]

EIGEN_STRONG_INLINE Packet16h Eigen::internal::float2half

(

const Packet16f &

a

)

float2half() [2/2]

EIGEN_STRONG_INLINE Packet8h Eigen::internal::float2half

(

const Packet8f &

a

)

fortran_to_c_numbering()

template<typename MatrixType >

void Eigen::internal::fortran_to_c_numbering

(

MatrixType &

mat

)

gemm()

template<typename Scalar , typename Index , typename Packet , typename RhsPacket , typename DataMapper , const Index accRows, const Index accCols>

EIGEN_STRONG_INLINE void Eigen::internal::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
	)

gemm_complex()

template<typename LhsScalar , typename RhsScalar , typename Scalarc , typename Scalar , typename Index , typename Packet , typename Packetc , typename RhsPacket , typename DataMapper , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>

EIGEN_STRONG_INLINE void Eigen::internal::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
	)

gemm_complex_extra_col()

template<typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>

EIGEN_STRONG_INLINE void Eigen::internal::gemm_complex_extra_col	(	const DataMapper &	res,
		const Scalar *	lhs_base,
		const Scalar *	rhs_base,
		Index	depth,
		Index	strideA,
		Index	offsetA,
		Index	strideB,
		Index	row,
		Index	col,
		Index	remaining_rows,
		Index	remaining_cols,
		const Packet &	pAlphaReal,
		const Packet &	pAlphaImag
	)

gemm_complex_extra_row()

template<typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>

EIGEN_STRONG_INLINE void Eigen::internal::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	col,
		Index	rows,
		Index	cols,
		Index	remaining_rows,
		const Packet &	pAlphaReal,
		const Packet &	pAlphaImag,
		const Packet &	pMask
	)

gemm_complex_unrolled_col()

template<typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>

EIGEN_STRONG_INLINE void Eigen::internal::gemm_complex_unrolled_col	(	const DataMapper &	res,
		const Scalar *	lhs_base,
		const Scalar *	rhs_base,
		Index	depth,
		Index	strideA,
		Index	offsetA,
		Index	strideB,
		Index &	row,
		Index	rows,
		Index	col,
		Index	remaining_cols,
		const Packet &	pAlphaReal,
		const Packet &	pAlphaImag
	)

gemm_complex_unrolled_col_iteration()

template<int unroll_factor, typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>

EIGEN_STRONG_INLINE void Eigen::internal::gemm_complex_unrolled_col_iteration	(	const DataMapper &	res,
		const Scalar *	lhs_base,
		const Scalar *	rhs_base,
		Index	depth,
		Index	strideA,
		Index	offsetA,
		Index	strideB,
		Index &	row,
		Index	col,
		Index	remaining_cols,
		const Packet &	pAlphaReal,
		const Packet &	pAlphaImag
	)

gemm_complex_unrolled_iteration()

template<int unroll_factor, typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>

EIGEN_STRONG_INLINE void Eigen::internal::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,
		Index	col,
		const Packet &	pAlphaReal,
		const Packet &	pAlphaImag
	)

gemm_complex_unrolled_MMA_iteration()

template<int unroll_factor, typename Scalar , typename Packet , typename Packetc , typename RhsPacket , typename DataMapper , typename Index , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>

EIGEN_STRONG_INLINE void Eigen::internal::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,
		Index	col,
		const Packet &	pAlphaReal,
		const Packet &	pAlphaImag
	)

gemm_complexMMA()

template<typename LhsScalar , typename RhsScalar , typename Scalarc , typename Scalar , typename Index , typename Packet , typename Packetc , typename RhsPacket , typename DataMapper , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>

void Eigen::internal::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
	)

gemm_extra_col()

template<typename Scalar , typename Packet , typename DataMapper , typename Index , const Index accRows>

EIGEN_STRONG_INLINE void Eigen::internal::gemm_extra_col	(	const DataMapper &	res,
		const Scalar *	lhs_base,
		const Scalar *	rhs_base,
		Index	depth,
		Index	strideA,
		Index	offsetA,
		Index	row,
		Index	col,
		Index	remaining_rows,
		Index	remaining_cols,
		const Packet &	pAlpha
	)

gemm_extra_row()

template<typename Scalar , typename Packet , typename DataMapper , typename Index , const Index accRows, const Index accCols>

EIGEN_STRONG_INLINE void Eigen::internal::gemm_extra_row	(	const DataMapper &	res,
		const Scalar *	lhs_base,
		const Scalar *	rhs_base,
		Index	depth,
		Index	strideA,
		Index	offsetA,
		Index	row,
		Index	col,
		Index	rows,
		Index	cols,
		Index	remaining_rows,
		const Packet &	pAlpha,
		const Packet &	pMask
	)

gemm_unrolled_col()

template<typename Scalar , typename Packet , typename DataMapper , typename Index , const Index accCols>

EIGEN_STRONG_INLINE void Eigen::internal::gemm_unrolled_col	(	const DataMapper &	res,
		const Scalar *	lhs_base,
		const Scalar *	rhs_base,
		Index	depth,
		Index	strideA,
		Index	offsetA,
		Index &	row,
		Index	rows,
		Index	col,
		Index	remaining_cols,
		const Packet &	pAlpha
	)

gemm_unrolled_col_iteration()

template<int unroll_factor, typename Scalar , typename Packet , typename DataMapper , typename Index , const Index accCols>

EIGEN_STRONG_INLINE void Eigen::internal::gemm_unrolled_col_iteration	(	const DataMapper &	res,
		const Scalar *	lhs_base,
		const Scalar *	rhs_base,
		Index	depth,
		Index	strideA,
		Index	offsetA,
		Index &	row,
		Index	col,
		Index	remaining_cols,
		const Packet &	pAlpha
	)

gemm_unrolled_iteration()

template<int unroll_factor, typename Scalar , typename Packet , typename DataMapper , typename Index , const Index accRows, const Index accCols>

EIGEN_STRONG_INLINE void Eigen::internal::gemm_unrolled_iteration	(	const DataMapper &	res,
		const Scalar *	lhs_base,
		const Scalar *	rhs_base,
		Index	depth,
		Index	strideA,
		Index	offsetA,
		Index &	row,
		Index	col,
		const Packet &	pAlpha
	)

gemm_unrolled_MMA_iteration()

template<int unroll_factor, typename Scalar , typename Packet , typename RhsPacket , typename DataMapper , typename Index , const Index accRows, const Index accCols>

EIGEN_STRONG_INLINE void Eigen::internal::gemm_unrolled_MMA_iteration	(	const DataMapper &	res,
		const Scalar *	lhs_base,
		const Scalar *	rhs_base,
		Index	depth,
		Index	strideA,
		Index	offsetA,
		Index &	row,
		Index	col,
		const Packet &	pAlpha
	)

gemmMMA()

template<typename Scalar , typename Index , typename Packet , typename RhsPacket , typename DataMapper , const Index accRows, const Index accCols>

void Eigen::internal::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
	)

general_det3_helper()

template<typename Derived >

EIGEN_DEVICE_FUNC const Derived::Scalar Eigen::internal::general_det3_helper ( const MatrixBase< Derived > &  matrix, int  i1, int  i2, int  i3, int  j1, int  j2, int  j3  )

inline

generic_expm1()

template<typename Packet >

Packet Eigen::internal::generic_expm1

(

const Packet &

x

)

generic_fast_erf_float()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T Eigen::internal::generic_fast_erf_float

(

const T &

a_x

)

generic_fast_tanh_float()

template<typename T >

T Eigen::internal::generic_fast_tanh_float

(

const T &

a_x

)

generic_ndtri()

template<typename T , typename ScalarType >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::internal::generic_ndtri

(

const T &

a

)

generic_ndtri_gt_exp_neg_two()

template<typename T , typename ScalarType >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T Eigen::internal::generic_ndtri_gt_exp_neg_two

(

const T &

b

)

generic_ndtri_lt_exp_neg_two()

template<typename T , typename ScalarType >

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

generic_plog1p()

template<typename Packet >

Packet Eigen::internal::generic_plog1p

(

const Packet &

x

)

generic_pow()

template<typename Packet >

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::generic_pow	(	const Packet &	x,
		const Packet &	y
	)

generic_pow_impl()

template<typename Packet >

EIGEN_STRONG_INLINE Packet Eigen::internal::generic_pow_impl	(	const Packet &	x,
		const Packet &	y
	)

get_runtime_reshape_size() [1/2]

Index Eigen::internal::get_runtime_reshape_size ( AutoSize_t  , Index  other, Index  total  )

inline

get_runtime_reshape_size() [2/2]

template<typename SizeType >

Index Eigen::internal::get_runtime_reshape_size	(	SizeType	size,
		Index	,
		Index
	)

get_runtime_value() [1/2]

template<typename T >

EIGEN_DEVICE_FUNC Index Eigen::internal::get_runtime_value

(

const T &

x

)

get_runtime_value() [2/2]

template<int N>

EIGEN_DEVICE_FUNC Index Eigen::internal::get_runtime_value

(

FixedInt< N >

*)(

)

getAdjointVal()

template<typename Scalar , typename Index , int StorageOrder>

EIGEN_ALWAYS_INLINE std::complex< Scalar > Eigen::internal::getAdjointVal	(	Index	i,
		Index	j,
		const_blas_data_mapper< std::complex< Scalar >, Index, StorageOrder > &	dt
	)

Symm packing is related to packing of symmetric adjoint blocks, as expected the packing leaves the diagonal real, whatever is below it is copied from the respective upper diagonal element and conjugated. There's no PanelMode available for symm packing.

Packing in general is supposed to leave the lhs block and the rhs block easy to be read by gemm using its respective rank-update instructions. The float32/64 versions are different because at this moment the size of the accumulator is fixed at 512-bits so you can't have a 4x4 accumulator of 64-bit elements.

As mentioned earlier MatrixProduct breaks complex numbers into a real vector and a complex vector so packing has to take that into account, at the moment, we run pack the real part and then the imaginary part, this is the main reason why packing for complex is broken down into several different parts, also the reason why we endup having a float32/64 and complex float32/64 version.

GetMarketLine() [1/6]

template<>

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

inline

GetMarketLine() [2/6]

template<>

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

inline

GetMarketLine() [3/6]

template<>

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

inline

GetMarketLine() [4/6]

template<>

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

inline

GetMarketLine() [5/6]

template<typename Scalar , typename StorageIndex >

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

inline

GetMarketLine() [6/6]

template<typename Scalar , typename StorageIndex >

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

inline

GetVectorElt() [1/2]

template<typename RealScalar >

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

inline

GetVectorElt() [2/2]

template<typename RealScalar >

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

inline

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.

h_array_apply()

template<typename Op , typename A , std::size_t N, int... n>

constexpr EIGEN_STRONG_INLINE array< decltype(Op::run(A())), N > Eigen::internal::h_array_apply ( array< A, N >  a, numeric_list< int, n... >    )

constexpr

h_array_apply_and_reduce()

template<typename Reducer , typename Op , typename A , std::size_t N, int... n>

constexpr EIGEN_STRONG_INLINE auto Eigen::internal::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

h_array_reverse()

template<typename Array , int... n>

constexpr EIGEN_STRONG_INLINE Array Eigen::internal::h_array_reverse ( Array  arr, numeric_list< int, n... >    )

constexpr

h_array_zip()

template<typename Op , typename A , typename B , std::size_t N, int... n>

constexpr EIGEN_STRONG_INLINE array< decltype(Op::run(A(), B())), N > Eigen::internal::h_array_zip ( array< A, N >  a, array< B, N >  b, numeric_list< int, n... >    )

constexpr

h_array_zip_and_reduce()

template<typename Reducer , typename Op , typename A , typename B , std::size_t N, int... n>

constexpr EIGEN_STRONG_INLINE auto Eigen::internal::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))...))

constexpr

half2float() [1/2]

EIGEN_STRONG_INLINE Packet16f Eigen::internal::half2float

(

const Packet16h &

a

)

half2float() [2/2]

EIGEN_STRONG_INLINE Packet8f Eigen::internal::half2float

(

const Packet8h &

a

)

handmade_aligned_free()

EIGEN_DEVICE_FUNC void Eigen::internal::handmade_aligned_free ( void *  ptr )

inline

handmade_aligned_malloc()

EIGEN_DEVICE_FUNC void * Eigen::internal::handmade_aligned_malloc ( std::size_t  size, std::size_t  alignment = EIGEN_DEFAULT_ALIGN_BYTES  )

inline

handmade_aligned_realloc()

void * Eigen::internal::handmade_aligned_realloc ( void *  ptr, std::size_t  size, std::size_t  = 0  )

inline

householder_qr_inplace_unblocked()

template<typename MatrixQR , typename HCoeffs >

void Eigen::internal::householder_qr_inplace_unblocked	(	MatrixQR &	mat,
		HCoeffs &	hCoeffs,
		typename MatrixQR::Scalar *	tempData = 0
	)

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
	)

igamma_num_iterations()

template<typename Scalar , IgammaComputationMode mode>

EIGEN_DEVICE_FUNC int Eigen::internal::igamma_num_iterations

(

)

ignore_unused_variable()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ignore_unused_variable

(

const T &

)

instantiate_by_c_array()

template<class InstType , typename ArrType , std::size_t N, bool Reverse = false>

InstType Eigen::internal::instantiate_by_c_array

(

ArrType *

arr

)

intersect_helper()

template<typename BVH , typename Intersector >

bool Eigen::internal::intersect_helper	(	const BVH &	tree,
		Intersector &	intersector,
		typename BVH::Index	root
	)

is_same_dense() [1/2]

template<typename T1 , typename T2 >

EIGEN_DEVICE_FUNC bool Eigen::internal::is_same_dense	(	const T1 &	,
		const T2 &	,
		typename enable_if<!possibly_same_dense< T1, T2 >::value >::type *	= 0
	)

is_same_dense() [2/2]

template<typename T1 , typename T2 >

EIGEN_DEVICE_FUNC bool Eigen::internal::is_same_dense	(	const T1 &	mat1,
		const T2 &	mat2,
		typename enable_if< possibly_same_dense< T1, T2 >::value >::type *	= 0
	)

isApprox()

template<typename Scalar >

EIGEN_DEVICE_FUNC bool Eigen::internal::isApprox ( const Scalar &  x, const Scalar &  y, const typename NumTraits< Scalar >::Real &  precision = NumTraits<Scalar>::dummy_precision()  )

inline

isApproxOrLessThan()

template<typename Scalar >

EIGEN_DEVICE_FUNC bool Eigen::internal::isApproxOrLessThan ( const Scalar &  x, const Scalar &  y, const typename NumTraits< Scalar >::Real &  precision = NumTraits<Scalar>::dummy_precision()  )

inline

isfinite_impl() [1/3]

template<typename T >

EIGEN_DEVICE_FUNC bool Eigen::internal::isfinite_impl

(

const std::complex< T > &

x

)

isfinite_impl() [2/3]

template<typename T >

EIGEN_DEVICE_FUNC internal::enable_if< internal::is_integral< T >::value, bool >::type Eigen::internal::isfinite_impl

(

const T &

)

isfinite_impl() [3/3]

template<typename T >

EIGEN_DEVICE_FUNC internal::enable_if<(!internal::is_integral< T >::value)&&(!NumTraits< T >::IsComplex), bool >::type Eigen::internal::isfinite_impl

(

const T &

x

)

isinf_impl() [1/3]

template<typename T >

EIGEN_DEVICE_FUNC bool Eigen::internal::isinf_impl

(

const std::complex< T > &

x

)

isinf_impl() [2/3]

template<typename T >

EIGEN_DEVICE_FUNC internal::enable_if< internal::is_integral< T >::value, bool >::type Eigen::internal::isinf_impl

(

const T &

)

isinf_impl() [3/3]

template<typename T >

EIGEN_DEVICE_FUNC internal::enable_if<(!internal::is_integral< T >::value)&&(!NumTraits< T >::IsComplex), bool >::type Eigen::internal::isinf_impl

(

const T &

x

)

isMuchSmallerThan()

template<typename Scalar , typename OtherScalar >

EIGEN_DEVICE_FUNC bool Eigen::internal::isMuchSmallerThan ( const Scalar &  x, const OtherScalar &  y, const typename NumTraits< Scalar >::Real &  precision = NumTraits<Scalar>::dummy_precision()  )

inline

isnan_impl() [1/3]

template<typename T >

EIGEN_DEVICE_FUNC bool Eigen::internal::isnan_impl

(

const std::complex< T > &

x

)

isnan_impl() [2/3]

template<typename T >

EIGEN_DEVICE_FUNC internal::enable_if< internal::is_integral< T >::value, bool >::type Eigen::internal::isnan_impl

(

const T &

)

isnan_impl() [3/3]

template<typename T >

EIGEN_DEVICE_FUNC internal::enable_if<(!internal::is_integral< T >::value)&&(!NumTraits< T >::IsComplex), bool >::type Eigen::internal::isnan_impl

(

const T &

x

)

least_square_conjugate_gradient()

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

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

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
	)

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
	)

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
	)

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
	)

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
	)

loadPacketRemaining() [1/2]

template<typename Scalar , typename Packet , typename Index >

EIGEN_ALWAYS_INLINE void Eigen::internal::loadPacketRemaining	(	const Scalar *	lhs,
		Packet &	lhsV,
		Index	remaining_rows
	)

loadPacketRemaining() [2/2]

template<typename Scalar , typename Packet , typename Index , bool LhsIsReal>

EIGEN_ALWAYS_INLINE void Eigen::internal::loadPacketRemaining	(	const Scalar *	lhs_ptr,
		const Scalar *	lhs_ptr_imag,
		Packet &	lhsV,
		Packet &	lhsVi,
		Index	remaining_rows
	)

loadQuadToDoublePacket() [1/2]

template<typename Scalar , typename RealPacket >

void Eigen::internal::loadQuadToDoublePacket	(	const Scalar *	b,
		DoublePacket< RealPacket > &	dest
	)

loadQuadToDoublePacket() [2/2]

template<typename Scalar , typename RealPacket >

void Eigen::internal::loadQuadToDoublePacket	(	const Scalar *	b,
		DoublePacket< RealPacket > &	dest,
		typename enable_if< unpacket_traits< RealPacket >::size==16 >::type *	= 0
	)

LUnumTempV()

Index Eigen::internal::LUnumTempV ( Index &  m, Index &  w, Index &  t, Index &  b  )

inline

LUTempSpace()

template<typename Scalar >

Index Eigen::internal::LUTempSpace ( Index &  m, Index &  w  )

inline

make_block_householder_triangular_factor()

template<typename TriangularFactorType , typename VectorsType , typename CoeffsType >

void Eigen::internal::make_block_householder_triangular_factor	(	TriangularFactorType &	triFactor,
		const VectorsType &	vectors,
		const CoeffsType &	hCoeffs
	)

make_coherent()

template<typename A , typename B >

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

make_coherent_expression() [1/3]

template<typename UnaryOp , typename A , typename RefType >

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

protected

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  )

protected

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  )

protected

makeIndexedViewCompatible() [1/4]

template<typename XprSizeType >

AllRange< get_fixed_value< XprSizeType >::value > Eigen::internal::makeIndexedViewCompatible ( all_t  , XprSizeType  size, SpecializedType    )

inline

makeIndexedViewCompatible() [2/4]

template<typename FirstType , typename SizeType , typename IncrType >

ArithmeticSequence< Index, typename make_size_type< SizeType >::type, IncrType > Eigen::internal::makeIndexedViewCompatible	(	const ArithmeticSequence< FirstType, SizeType, IncrType > &	ids,
		Index	size,
		SpecializedType
	)

makeIndexedViewCompatible() [3/4]

template<typename T >

enable_if< symbolic::is_symbolic< T >::value, SingleRange >::type Eigen::internal::makeIndexedViewCompatible	(	const T &	id,
		Index	size,
		SpecializedType
	)

makeIndexedViewCompatible() [4/4]

template<typename T , typename Q >

const T & Eigen::internal::makeIndexedViewCompatible	(	const T &	x,
		Index	,
		Q
	)

manage_caching_sizes()

void Eigen::internal::manage_caching_sizes ( Action  action, std::ptrdiff_t *  l1, std::ptrdiff_t *  l2, std::ptrdiff_t *  l3  )

inline

manage_caching_sizes_helper()

std::ptrdiff_t Eigen::internal::manage_caching_sizes_helper ( std::ptrdiff_t  a, std::ptrdiff_t  b  )

inline

manage_multi_threading()

void Eigen::internal::manage_multi_threading ( Action  action, int *  v  )

inline

map_superlu()

template<typename Scalar , int Flags, typename Index >

MappedSparseMatrix< Scalar, Flags, Index > Eigen::internal::map_superlu

(

SluMatrix &

sluMat

)

View a Super LU matrix as an Eigen expression

matrix_exp_compute() [1/2]

template<typename ArgType , typename ResultType >

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

matrix_exp_compute() [2/2]

template<typename ArgType , typename ResultType >

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

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, is the Padé approximant of around .

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, is the Padé approximant of around .

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, is the Padé approximant of around .

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, is the Padé approximant of around .

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, is the Padé approximant of around .

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.

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.

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.

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.

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.

matrix_function_compute_mu()

template<typename MatrixType >

NumTraits< typenameMatrixType::Scalar >::Real Eigen::internal::matrix_function_compute_mu

(

const MatrixType &

A

)

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.

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.

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.

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.

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

This can be re-arranged to yield:

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 and .

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.

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.

matrix_log_compute_pade()

template<typename MatrixType >

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

matrix_log_get_pade_degree() [1/3]

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

inline

matrix_log_get_pade_degree() [2/3]

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

inline

matrix_log_get_pade_degree() [3/3]

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

inline

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
	)

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
	)

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
	)

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
	)

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
	)

matrix_sqrt_quasi_triangular_diagonal()

template<typename MatrixType , typename ResultType >

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

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
	)

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
	)

MICRO_COMPLEX_EXTRA_COL()

template<typename Scalar , typename Packet , typename Index , const Index accRows, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>

EIGEN_ALWAYS_INLINE void Eigen::internal::MICRO_COMPLEX_EXTRA_COL	(	const Scalar *&	lhs_ptr_real,
		const Scalar *&	lhs_ptr_imag,
		const Scalar *&	rhs_ptr_real,
		const Scalar *&	rhs_ptr_imag,
		PacketBlock< Packet, 1 > &	accReal,
		PacketBlock< Packet, 1 > &	accImag,
		Index	remaining_rows,
		Index	remaining_cols
	)

MICRO_COMPLEX_EXTRA_ROW()

template<typename Scalar , typename Packet , typename Index , const Index accRows, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>

EIGEN_ALWAYS_INLINE void Eigen::internal::MICRO_COMPLEX_EXTRA_ROW	(	const Scalar *&	lhs_ptr_real,
		const Scalar *&	lhs_ptr_imag,
		const Scalar *&	rhs_ptr_real,
		const Scalar *&	rhs_ptr_imag,
		PacketBlock< Packet, 4 > &	accReal,
		PacketBlock< Packet, 4 > &	accImag,
		Index	remaining_rows
	)

MICRO_EXTRA_COL()

template<typename Scalar , typename Packet , typename Index >

EIGEN_ALWAYS_INLINE void Eigen::internal::MICRO_EXTRA_COL	(	const Scalar *&	lhs_ptr,
		const Scalar *&	rhs_ptr,
		PacketBlock< Packet, 1 > &	accZero,
		Index	remaining_rows,
		Index	remaining_cols
	)

MICRO_EXTRA_ROW()

template<typename Scalar , typename Packet , typename Index , const Index accRows>

EIGEN_ALWAYS_INLINE void Eigen::internal::MICRO_EXTRA_ROW	(	const Scalar *&	lhs_ptr,
		const Scalar *&	rhs_ptr,
		PacketBlock< Packet, 4 > &	accZero,
		Index	remaining_rows
	)

minimum_degree_ordering()

template<typename Scalar , typename StorageIndex >

void Eigen::internal::minimum_degree_ordering	(	SparseMatrix< Scalar, ColMajor, StorageIndex > &	C,
		PermutationMatrix< Dynamic, Dynamic, StorageIndex > &	perm
	)

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
	)

negate()

template<typename T >

T Eigen::internal::negate

(

const T &

x

)

nr_etdfs()

template<typename IndexVector >

void Eigen::internal::nr_etdfs	(	typename IndexVector::Scalar	n,
		IndexVector &	parent,
		IndexVector &	first_kid,
		IndexVector &	next_kid,
		IndexVector &	post,
		typename IndexVector::Scalar	postnum
	)

Depth-first search from vertex n. No recursion. This routine was contributed by Cédric Doucet, CEDRAT Group, Meylan, France.

omega()

template<typename Vector , typename RealScalar >

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

operator!=()

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

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

operator+()

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

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

operator-()

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

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

operator<()

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

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

operator<<() [1/15]

std::ostream & Eigen::internal::operator<< ( std::ostream &  os, const Packet1cd &  value  )

inline

operator<<() [2/15]

std::ostream & Eigen::internal::operator<< ( std::ostream &  os, const Packet2cf &  value  )

inline

operator<<() [3/15]

std::ostream & Eigen::internal::operator<< ( std::ostream &  os, const Packet2d &  value  )

inline

operator<<() [4/15]

std::ostream & Eigen::internal::operator<< ( std::ostream &  os, const Packet2l &  value  )

inline

operator<<() [5/15]

std::ostream & Eigen::internal::operator<< ( std::ostream &  os, const Packet2ul &  value  )

inline

operator<<() [6/15]

std::ostream & Eigen::internal::operator<< ( std::ostream &  os, const PacketBlock< Packet1cd, 2 > &  value  )

inline

operator<<() [7/15]

std::ostream & Eigen::internal::operator<< ( std::ostream &  os, const PacketBlock< Packet2cf, 2 > &  value  )

inline

operator<<() [8/15]

std::ostream & Eigen::internal::operator<< ( std::ostream &  os, const PacketBlock< Packet2d, 2 > &  value  )

inline

operator<<() [9/15]

std::ostream & Eigen::internal::operator<< ( std::ostream &  os, const PacketBlock< Packet4f, 4 > &  value  )

inline

operator<<() [10/15]

std::ostream & Eigen::internal::operator<< ( std::ostream &  os, const PacketBlock< Packet4i, 4 > &  value  )

inline

operator<<() [11/15]

std::ostream & Eigen::internal::operator<< ( std::ostream &  s, const Packet16c &  v  )

inline

operator<<() [12/15]

std::ostream & Eigen::internal::operator<< ( std::ostream &  s, const Packet16uc &  v  )

inline

operator<<() [13/15]

std::ostream & Eigen::internal::operator<< ( std::ostream &  s, const Packet4f &  v  )

inline

operator<<() [14/15]

std::ostream & Eigen::internal::operator<< ( std::ostream &  s, const Packet4i &  v  )

inline

operator<<() [15/15]

std::ostream & Eigen::internal::operator<< ( std::ostream &  s, const Packet4ui &  v  )

inline

operator==()

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

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

operator>=()

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

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

ordering_helper_at_plus_a()

template<typename MatrixType >

void Eigen::internal::ordering_helper_at_plus_a	(	const MatrixType &	A,
		MatrixType &	symmat
	)

outer_product_selector_run() [1/2]

template<typename Dst , typename Lhs , typename Rhs , typename Func >

void EIGEN_DEVICE_FUNC Eigen::internal::outer_product_selector_run	(	Dst &	dst,
		const Lhs &	lhs,
		const Rhs &	rhs,
		const Func &	func,
		const false_type &
	)

outer_product_selector_run() [2/2]

template<typename Dst , typename Lhs , typename Rhs , typename Func >

void EIGEN_DEVICE_FUNC Eigen::internal::outer_product_selector_run	(	Dst &	dst,
		const Lhs &	lhs,
		const Rhs &	rhs,
		const Func &	func,
		const true_type &
	)

p2ui_CONJ_XOR()

uint32x2_t Eigen::internal::p2ui_CONJ_XOR ( )

inline

pabs() [1/45]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pabs ( const Packet &  a )

inline

pabs() [2/45]

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pabs

(

const Packet16bf &

a

)

pabs() [3/45]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pabs

(

const Packet16c &

a

)

pabs() [4/45]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pabs

(

const Packet16c &

a

)

pabs() [5/45]

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pabs

(

const Packet16f &

a

)

pabs() [6/45]

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pabs

(

const Packet16h &

a

)

pabs() [7/45]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pabs

(

const Packet16uc &

a

)

pabs() [8/45]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pabs

(

const Packet16uc &

a

)

pabs() [9/45]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pabs

(

const Packet2d &

a

)

pabs() [10/45]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pabs

(

const Packet2d &

a

)

pabs() [11/45]

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pabs

(

const Packet2f &

a

)

pabs() [12/45]

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pabs

(

const Packet2i &

a

)

pabs() [13/45]

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pabs

(

const Packet2l &

a

)

pabs() [14/45]

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pabs

(

const Packet2ui &

a

)

pabs() [15/45]

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pabs

(

const Packet2ul &

a

)

pabs() [16/45]

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pabs

(

const Packet4bf &

a

)

pabs() [17/45]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pabs

(

const Packet4d &

a

)

pabs() [18/45]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pabs

(

const Packet4f &

a

)

pabs() [19/45]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pabs

(

const Packet4f &

a

)

pabs() [20/45]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pabs

(

const Packet4f &

a

)

pabs() [21/45]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pabs

(

const Packet4f &

a

)

pabs() [22/45]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pabs

(

const Packet4i &

a

)

pabs() [23/45]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pabs

(

const Packet4i &

a

)

pabs() [24/45]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pabs

(

const Packet4i &

a

)

pabs() [25/45]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pabs

(

const Packet4i &

a

)

pabs() [26/45]

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pabs

(

const Packet4s &

a

)

pabs() [27/45]

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pabs

(

const Packet4uc &

a

)

pabs() [28/45]

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pabs

(

const Packet4ui &

a

)

pabs() [29/45]

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pabs

(

const Packet4us &

a

)

pabs() [30/45]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pabs

(

const Packet8bf &

a

)

pabs() [31/45]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pabs

(

const Packet8bf &

a

)

pabs() [32/45]

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pabs

(

const Packet8c &

a

)

pabs() [33/45]

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pabs

(

const Packet8d &

a

)

pabs() [34/45]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pabs

(

const Packet8f &

a

)

pabs() [35/45]

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pabs

(

const Packet8h &

a

)

pabs() [36/45]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pabs

(

const Packet8s &

a

)

pabs() [37/45]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pabs

(

const Packet8s &

a

)

pabs() [38/45]

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pabs

(

const Packet8uc &

a

)

pabs() [39/45]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pabs

(

const Packet8us &

a

)

pabs() [40/45]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pabs

(

const Packet8us &

a

)

pabs() [41/45]

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pabs

(

const PacketXf &

a

)

pabs() [42/45]

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pabs

(

const PacketXi &

a

)

pabs() [43/45]

template<>

EIGEN_DEVICE_FUNC unsigned int Eigen::internal::pabs ( const unsigned int &  a )

inline

pabs() [44/45]

template<>

EIGEN_DEVICE_FUNC unsigned long Eigen::internal::pabs ( const unsigned long &  a )

inline

pabs() [45/45]

template<>

EIGEN_DEVICE_FUNC unsigned long long Eigen::internal::pabs ( const unsigned long long &  a )

inline

pabs< Packet2d >()

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pabs< Packet2d >

(

const Packet2d &

a

)

pabs< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pabs< Packet4c >

(

const Packet4c &

a

)

pabs< Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pabs< Packet4f >

(

const Packet4f &

a

)

pabs< Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pabs< Packet4i >

(

const Packet4i &

a

)

pabsdiff()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pabsdiff ( const Packet &  a, const Packet &  b  )

inline

pabsdiff< Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pabsdiff< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

pabsdiff< Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pabsdiff< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

pabsdiff< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pabsdiff< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

pabsdiff< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pabsdiff< Packet2i >	(	const Packet2i &	a,
		const Packet2i &	b
	)

pabsdiff< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pabsdiff< Packet2ui >	(	const Packet2ui &	a,
		const Packet2ui &	b
	)

pabsdiff< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pabsdiff< Packet4bf >	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

pabsdiff< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pabsdiff< Packet4c >	(	const Packet4c &	a,
		const Packet4c &	b
	)

pabsdiff< Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pabsdiff< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pabsdiff< Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pabsdiff< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pabsdiff< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pabsdiff< Packet4s >	(	const Packet4s &	a,
		const Packet4s &	b
	)

pabsdiff< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pabsdiff< Packet4uc >	(	const Packet4uc &	a,
		const Packet4uc &	b
	)

pabsdiff< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pabsdiff< Packet4ui >	(	const Packet4ui &	a,
		const Packet4ui &	b
	)

pabsdiff< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pabsdiff< Packet4us >	(	const Packet4us &	a,
		const Packet4us &	b
	)

pabsdiff< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pabsdiff< Packet8c >	(	const Packet8c &	a,
		const Packet8c &	b
	)

pabsdiff< Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pabsdiff< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

pabsdiff< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pabsdiff< Packet8uc >	(	const Packet8uc &	a,
		const Packet8uc &	b
	)

pabsdiff< Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pabsdiff< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

Pack16To8()

EIGEN_STRONG_INLINE __m128i Eigen::internal::Pack16To8

(

Packet8f

rf

)

Pack32To16()

EIGEN_STRONG_INLINE __m256i Eigen::internal::Pack32To16

(

Packet16f

rf

)

packetwise_redux_empty_value() [1/2]

template<typename PacketType , typename Func >

EIGEN_DEVICE_FUNC PacketType Eigen::internal::packetwise_redux_empty_value

(

const Func &

)

packetwise_redux_empty_value() [2/2]

template<typename PacketType , typename Scalar >

EIGEN_DEVICE_FUNC PacketType Eigen::internal::packetwise_redux_empty_value

(

const scalar_product_op< Scalar, Scalar > &

)

pacos()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pacos

(

const Packet &

a

)

padd() [1/3]

template<>

EIGEN_DEVICE_FUNC bool Eigen::internal::padd ( const bool &  a, const bool &  b  )

inline

padd() [2/3]

template<typename Packet >

DoublePacket< Packet > Eigen::internal::padd	(	const DoublePacket< Packet > &	a,
		const DoublePacket< Packet > &	b
	)

padd() [3/3]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::padd ( const Packet &  a, const Packet &  b  )

inline

padd< Packet16b >()

template<>

EIGEN_STRONG_INLINE Packet16b Eigen::internal::padd< Packet16b >	(	const Packet16b &	a,
		const Packet16b &	b
	)

padd< Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::padd< Packet16bf >	(	const Packet16bf &	a,
		const Packet16bf &	b
	)

padd< Packet16c >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::padd< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

padd< Packet16c >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::padd< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

padd< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::padd< Packet16f >	(	const Packet16f &	a,
		const Packet16f &	b
	)

padd< Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::padd< Packet16h >	(	const Packet16h &	a,
		const Packet16h &	b
	)

padd< Packet16i >()

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::padd< Packet16i >	(	const Packet16i &	a,
		const Packet16i &	b
	)

padd< Packet16uc >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::padd< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

padd< Packet16uc >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::padd< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

padd< Packet1cd >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::padd< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

padd< Packet1cd >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::padd< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

padd< Packet1cd >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::padd< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

padd< Packet1cf >()

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::padd< Packet1cf >	(	const Packet1cf &	a,
		const Packet1cf &	b
	)

padd< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::padd< Packet2cd >	(	const Packet2cd &	a,
		const Packet2cd &	b
	)

padd< Packet2cf >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::padd< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

padd< Packet2cf >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::padd< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

padd< Packet2cf >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::padd< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

padd< Packet2cf >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::padd< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

padd< Packet2cf >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::padd< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

padd< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::padd< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

padd< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::padd< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

padd< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::padd< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

padd< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::padd< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

padd< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::padd< Packet2i >	(	const Packet2i &	a,
		const Packet2i &	b
	)

padd< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::padd< Packet2l >	(	const Packet2l &	a,
		const Packet2l &	b
	)

padd< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::padd< Packet2ui >	(	const Packet2ui &	a,
		const Packet2ui &	b
	)

padd< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::padd< Packet2ul >	(	const Packet2ul &	a,
		const Packet2ul &	b
	)

padd< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::padd< Packet4bf >	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

padd< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::padd< Packet4c >	(	const Packet4c &	a,
		const Packet4c &	b
	)

padd< Packet4cd >()

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::padd< Packet4cd >	(	const Packet4cd &	a,
		const Packet4cd &	b
	)

padd< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::padd< Packet4cf >	(	const Packet4cf &	a,
		const Packet4cf &	b
	)

padd< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::padd< Packet4d >	(	const Packet4d &	a,
		const Packet4d &	b
	)

padd< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::padd< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

padd< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::padd< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

padd< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::padd< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

padd< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::padd< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

padd< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::padd< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

padd< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::padd< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

padd< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::padd< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

padd< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::padd< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

padd< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::padd< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

padd< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::padd< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

padd< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::padd< Packet4s >	(	const Packet4s &	a,
		const Packet4s &	b
	)

padd< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::padd< Packet4uc >	(	const Packet4uc &	a,
		const Packet4uc &	b
	)

padd< Packet4ui >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::padd< Packet4ui >	(	const Packet4ui &	a,
		const Packet4ui &	b
	)

padd< Packet4ui >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::padd< Packet4ui >	(	const Packet4ui &	a,
		const Packet4ui &	b
	)

padd< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::padd< Packet4us >	(	const Packet4us &	a,
		const Packet4us &	b
	)

padd< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::padd< Packet8bf >	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

padd< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::padd< Packet8bf >	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

padd< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::padd< Packet8c >	(	const Packet8c &	a,
		const Packet8c &	b
	)

padd< Packet8cf >()

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::padd< Packet8cf >	(	const Packet8cf &	a,
		const Packet8cf &	b
	)

padd< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::padd< Packet8d >	(	const Packet8d &	a,
		const Packet8d &	b
	)

padd< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::padd< Packet8f >	(	const Packet8f &	a,
		const Packet8f &	b
	)

padd< Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::padd< Packet8h >	(	const Packet8h &	a,
		const Packet8h &	b
	)

padd< Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::padd< Packet8i >	(	const Packet8i &	a,
		const Packet8i &	b
	)

padd< Packet8s >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::padd< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

padd< Packet8s >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::padd< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

padd< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::padd< Packet8uc >	(	const Packet8uc &	a,
		const Packet8uc &	b
	)

padd< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::padd< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

padd< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::padd< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

padd< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::padd< PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

padd< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::padd< PacketXi >	(	const PacketXi &	a,
		const PacketXi &	b
	)

paddsub()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::paddsub ( const Packet &  a, const Packet &  b  )

inline

paddsub< Packet2d >()

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::paddsub< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

paddsub< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::paddsub< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

paddsub< Packet4f >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::paddsub< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

paddsub< Packet4f >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::paddsub< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pand() [1/6]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pand ( const Packet &  a, const Packet &  b  )

inline

pand() [2/6]

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pand	(	const Packet16bf &	a,
		const Packet16bf &	b
	)

pand() [3/6]

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pand	(	const Packet16h &	a,
		const Packet16h &	b
	)

pand() [4/6]

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pand	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

pand() [5/6]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pand	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pand() [6/6]

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pand	(	const Packet8h &	a,
		const Packet8h &	b
	)

pand< Packet16b >()

template<>

EIGEN_STRONG_INLINE Packet16b Eigen::internal::pand< Packet16b >	(	const Packet16b &	a,
		const Packet16b &	b
	)

pand< Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pand< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

pand< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pand< Packet16f >	(	const Packet16f &	a,
		const Packet16f &	b
	)

pand< Packet16i >()

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::pand< Packet16i >	(	const Packet16i &	a,
		const Packet16i &	b
	)

pand< Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pand< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

pand< Packet1cd >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pand< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

pand< Packet1cd >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pand< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

pand< Packet1cd >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pand< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

pand< Packet1cf >()

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pand< Packet1cf >	(	const Packet1cf &	a,
		const Packet1cf &	b
	)

pand< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pand< Packet2cd >	(	const Packet2cd &	a,
		const Packet2cd &	b
	)

pand< Packet2cf >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pand< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pand< Packet2cf >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pand< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pand< Packet2cf >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pand< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pand< Packet2cf >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pand< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pand< Packet2cf >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pand< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pand< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pand< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pand< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pand< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pand< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pand< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pand< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pand< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

pand< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pand< Packet2i >	(	const Packet2i &	a,
		const Packet2i &	b
	)

pand< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pand< Packet2l >	(	const Packet2l &	a,
		const Packet2l &	b
	)

pand< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pand< Packet2ui >	(	const Packet2ui &	a,
		const Packet2ui &	b
	)

pand< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pand< Packet2ul >	(	const Packet2ul &	a,
		const Packet2ul &	b
	)

pand< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pand< Packet4c >	(	const Packet4c &	a,
		const Packet4c &	b
	)

pand< Packet4cd >()

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pand< Packet4cd >	(	const Packet4cd &	a,
		const Packet4cd &	b
	)

pand< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pand< Packet4cf >	(	const Packet4cf &	a,
		const Packet4cf &	b
	)

pand< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pand< Packet4d >	(	const Packet4d &	a,
		const Packet4d &	b
	)

pand< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pand< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pand< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pand< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pand< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pand< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pand< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pand< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pand< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pand< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pand< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pand< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pand< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pand< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pand< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pand< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pand< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pand< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pand< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pand< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pand< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pand< Packet4s >	(	const Packet4s &	a,
		const Packet4s &	b
	)

pand< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pand< Packet4uc >	(	const Packet4uc &	a,
		const Packet4uc &	b
	)

pand< Packet4ui >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pand< Packet4ui >	(	const Packet4ui &	a,
		const Packet4ui &	b
	)

pand< Packet4ui >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pand< Packet4ui >	(	const Packet4ui &	a,
		const Packet4ui &	b
	)

pand< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pand< Packet4us >	(	const Packet4us &	a,
		const Packet4us &	b
	)

pand< Packet8bf >()

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pand< Packet8bf >	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pand< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pand< Packet8c >	(	const Packet8c &	a,
		const Packet8c &	b
	)

pand< Packet8cf >()

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pand< Packet8cf >	(	const Packet8cf &	a,
		const Packet8cf &	b
	)

pand< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pand< Packet8d >	(	const Packet8d &	a,
		const Packet8d &	b
	)

pand< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pand< Packet8f >	(	const Packet8f &	a,
		const Packet8f &	b
	)

pand< Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::pand< Packet8i >	(	const Packet8i &	a,
		const Packet8i &	b
	)

pand< Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pand< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

pand< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pand< Packet8uc >	(	const Packet8uc &	a,
		const Packet8uc &	b
	)

pand< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pand< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

pand< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pand< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

pand< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pand< PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

pand< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pand< PacketXi >	(	const PacketXi &	a,
		const PacketXi &	b
	)

pandnot() [1/6]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pandnot ( const Packet &  a, const Packet &  b  )

inline

pandnot() [2/6]

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pandnot	(	const Packet16bf &	a,
		const Packet16bf &	b
	)

pandnot() [3/6]

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pandnot	(	const Packet16h &	a,
		const Packet16h &	b
	)

pandnot() [4/6]

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pandnot	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

pandnot() [5/6]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pandnot	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pandnot() [6/6]

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pandnot	(	const Packet8h &	a,
		const Packet8h &	b
	)

pandnot< Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pandnot< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

pandnot< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pandnot< Packet16f >	(	const Packet16f &	a,
		const Packet16f &	b
	)

pandnot< Packet16i >()

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::pandnot< Packet16i >	(	const Packet16i &	a,
		const Packet16i &	b
	)

pandnot< Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pandnot< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

pandnot< Packet1cd >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pandnot< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

pandnot< Packet1cd >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pandnot< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

pandnot< Packet1cd >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pandnot< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

pandnot< Packet1cf >()

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pandnot< Packet1cf >	(	const Packet1cf &	a,
		const Packet1cf &	b
	)

pandnot< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pandnot< Packet2cd >	(	const Packet2cd &	a,
		const Packet2cd &	b
	)

pandnot< Packet2cf >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pandnot< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pandnot< Packet2cf >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pandnot< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pandnot< Packet2cf >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pandnot< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pandnot< Packet2cf >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pandnot< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pandnot< Packet2cf >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pandnot< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pandnot< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pandnot< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pandnot< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pandnot< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pandnot< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pandnot< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pandnot< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pandnot< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

pandnot< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pandnot< Packet2i >	(	const Packet2i &	a,
		const Packet2i &	b
	)

pandnot< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pandnot< Packet2l >	(	const Packet2l &	a,
		const Packet2l &	b
	)

pandnot< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pandnot< Packet2ui >	(	const Packet2ui &	a,
		const Packet2ui &	b
	)

pandnot< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pandnot< Packet2ul >	(	const Packet2ul &	a,
		const Packet2ul &	b
	)

pandnot< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pandnot< Packet4c >	(	const Packet4c &	a,
		const Packet4c &	b
	)

pandnot< Packet4cd >()

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pandnot< Packet4cd >	(	const Packet4cd &	a,
		const Packet4cd &	b
	)

pandnot< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pandnot< Packet4cf >	(	const Packet4cf &	a,
		const Packet4cf &	b
	)

pandnot< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pandnot< Packet4d >	(	const Packet4d &	a,
		const Packet4d &	b
	)

pandnot< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pandnot< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pandnot< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pandnot< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pandnot< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pandnot< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pandnot< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pandnot< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pandnot< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pandnot< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pandnot< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pandnot< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pandnot< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pandnot< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pandnot< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pandnot< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pandnot< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pandnot< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pandnot< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pandnot< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pandnot< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pandnot< Packet4s >	(	const Packet4s &	a,
		const Packet4s &	b
	)

pandnot< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pandnot< Packet4uc >	(	const Packet4uc &	a,
		const Packet4uc &	b
	)

pandnot< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pandnot< Packet4ui >	(	const Packet4ui &	a,
		const Packet4ui &	b
	)

pandnot< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pandnot< Packet4us >	(	const Packet4us &	a,
		const Packet4us &	b
	)

pandnot< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pandnot< Packet8c >	(	const Packet8c &	a,
		const Packet8c &	b
	)

pandnot< Packet8cf >()

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pandnot< Packet8cf >	(	const Packet8cf &	a,
		const Packet8cf &	b
	)

pandnot< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pandnot< Packet8d >	(	const Packet8d &	a,
		const Packet8d &	b
	)

pandnot< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pandnot< Packet8f >	(	const Packet8f &	a,
		const Packet8f &	b
	)

pandnot< Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::pandnot< Packet8i >	(	const Packet8i &	a,
		const Packet8i &	b
	)

pandnot< Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pandnot< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

pandnot< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pandnot< Packet8uc >	(	const Packet8uc &	a,
		const Packet8uc &	b
	)

pandnot< Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pandnot< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

pandnot< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pandnot< PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

pandnot< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pandnot< PacketXi >	(	const PacketXi &	a,
		const PacketXi &	b
	)

parallelize_gemm()

template<bool Condition, typename Functor , typename Index >

void Eigen::internal::parallelize_gemm	(	const Functor &	func,
		Index	rows,
		Index	cols,
		Index	depth,
		bool	transpose
	)

parg()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::parg ( const Packet &  a )

inline

parithmetic_shift_right() [1/22]

template<int N>

EIGEN_DEVICE_FUNC int Eigen::internal::parithmetic_shift_right ( const int &  a )

inline

parithmetic_shift_right() [2/22]

template<int N>

EIGEN_DEVICE_FUNC long int Eigen::internal::parithmetic_shift_right ( const long int &  a )

inline

parithmetic_shift_right() [3/22]

template<int N>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::parithmetic_shift_right

(

const Packet4i &

a

)

parithmetic_shift_right() [4/22]

template<int N>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::parithmetic_shift_right

(

Packet16c

a

)

parithmetic_shift_right() [5/22]

template<int N>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::parithmetic_shift_right

(

Packet16i

a

)

parithmetic_shift_right() [6/22]

template<int N>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::parithmetic_shift_right

(

Packet16uc

a

)

parithmetic_shift_right() [7/22]

template<int N>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::parithmetic_shift_right

(

Packet2i

a

)

parithmetic_shift_right() [8/22]

template<int N>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::parithmetic_shift_right

(

Packet2l

a

)

parithmetic_shift_right() [9/22]

template<int N>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::parithmetic_shift_right

(

Packet2ui

a

)

parithmetic_shift_right() [10/22]

template<int N>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::parithmetic_shift_right

(

Packet2ul

a

)

parithmetic_shift_right() [11/22]

template<int N>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::parithmetic_shift_right

(

Packet4c &

a

)

parithmetic_shift_right() [12/22]

template<int N>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::parithmetic_shift_right

(

Packet4i

a

)

parithmetic_shift_right() [13/22]

template<int N>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::parithmetic_shift_right

(

Packet4s

a

)

parithmetic_shift_right() [14/22]

template<int N>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::parithmetic_shift_right

(

Packet4uc &

a

)

parithmetic_shift_right() [15/22]

template<int N>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::parithmetic_shift_right

(

Packet4ui

a

)

parithmetic_shift_right() [16/22]

template<int N>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::parithmetic_shift_right

(

Packet4us

a

)

parithmetic_shift_right() [17/22]

template<int N>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::parithmetic_shift_right

(

Packet8c

a

)

parithmetic_shift_right() [18/22]

template<int N>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::parithmetic_shift_right

(

Packet8i

a

)

parithmetic_shift_right() [19/22]

template<int N>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::parithmetic_shift_right

(

Packet8s

a

)

parithmetic_shift_right() [20/22]

template<int N>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::parithmetic_shift_right

(

Packet8uc

a

)

parithmetic_shift_right() [21/22]

template<int N>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::parithmetic_shift_right

(

Packet8us

a

)

parithmetic_shift_right() [22/22]

template<int N>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::parithmetic_shift_right

(

PacketXi

a

)

partial_lu_inplace()

template<typename MatrixType , typename TranspositionType >

void Eigen::internal::partial_lu_inplace	(	MatrixType &	lu,
		TranspositionType &	row_transpositions,
		typename TranspositionType::StorageIndex &	nb_transpositions
	)

pasin()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pasin

(

const Packet &

a

)

patan()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::patan

(

const Packet &

a

)

pbessel_i0()

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_i0

(

const Packet &

x

)

pbessel_i0e()

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_i0e

(

const Packet &

x

)

pbessel_i1()

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_i1

(

const Packet &

x

)

pbessel_i1e()

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_i1e

(

const Packet &

x

)

pbessel_j0()

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_j0

(

const Packet &

x

)

pbessel_j1()

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_j1

(

const Packet &

x

)

pbessel_k0()

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_k0

(

const Packet &

x

)

pbessel_k0e()

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_k0e

(

const Packet &

x

)

pbessel_k1()

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_k1

(

const Packet &

x

)

pbessel_k1e()

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_k1e

(

const Packet &

x

)

pbessel_y0()

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_y0

(

const Packet &

x

)

pbessel_y1()

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_y1

(

const Packet &

x

)

pbetainc()

template<typename Packet >

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

pblend() [1/24]

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pblend	(	const Selector< 16 > &	,
		const Packet16f &	,
		const Packet16f &
	)

pblend() [2/24]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pblend	(	const Selector< 16 > &	ifPacket,
		const Packet16c &	thenPacket,
		const Packet16c &	elsePacket
	)

pblend() [3/24]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pblend	(	const Selector< 16 > &	ifPacket,
		const Packet16uc &	thenPacket,
		const Packet16uc &	elsePacket
	)

pblend() [4/24]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pblend	(	const Selector< 2 > &	ifPacket,
		const Packet2cf &	thenPacket,
		const Packet2cf &	elsePacket
	)

pblend() [5/24]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pblend	(	const Selector< 2 > &	ifPacket,
		const Packet2cf &	thenPacket,
		const Packet2cf &	elsePacket
	)

pblend() [6/24]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pblend	(	const Selector< 2 > &	ifPacket,
		const Packet2cf &	thenPacket,
		const Packet2cf &	elsePacket
	)

pblend() [7/24]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pblend	(	const Selector< 2 > &	ifPacket,
		const Packet2d &	thenPacket,
		const Packet2d &	elsePacket
	)

pblend() [8/24]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pblend	(	const Selector< 2 > &	ifPacket,
		const Packet2d &	thenPacket,
		const Packet2d &	elsePacket
	)

pblend() [9/24]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pblend	(	const Selector< 2 > &	ifPacket,
		const Packet2d &	thenPacket,
		const Packet2d &	elsePacket
	)

pblend() [10/24]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pblend	(	const Selector< 4 > &	ifPacket,
		const Packet4d &	thenPacket,
		const Packet4d &	elsePacket
	)

pblend() [11/24]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pblend	(	const Selector< 4 > &	ifPacket,
		const Packet4f &	thenPacket,
		const Packet4f &	elsePacket
	)

pblend() [12/24]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pblend	(	const Selector< 4 > &	ifPacket,
		const Packet4f &	thenPacket,
		const Packet4f &	elsePacket
	)

pblend() [13/24]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pblend	(	const Selector< 4 > &	ifPacket,
		const Packet4f &	thenPacket,
		const Packet4f &	elsePacket
	)

pblend() [14/24]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pblend	(	const Selector< 4 > &	ifPacket,
		const Packet4f &	thenPacket,
		const Packet4f &	elsePacket
	)

pblend() [15/24]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pblend	(	const Selector< 4 > &	ifPacket,
		const Packet4i &	thenPacket,
		const Packet4i &	elsePacket
	)

pblend() [16/24]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pblend	(	const Selector< 4 > &	ifPacket,
		const Packet4i &	thenPacket,
		const Packet4i &	elsePacket
	)

pblend() [17/24]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pblend	(	const Selector< 4 > &	ifPacket,
		const Packet4i &	thenPacket,
		const Packet4i &	elsePacket
	)

pblend() [18/24]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pblend	(	const Selector< 4 > &	ifPacket,
		const Packet4i &	thenPacket,
		const Packet4i &	elsePacket
	)

pblend() [19/24]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pblend	(	const Selector< 8 > &	ifPacket,
		const Packet8bf &	thenPacket,
		const Packet8bf &	elsePacket
	)

pblend() [20/24]

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pblend	(	const Selector< 8 > &	ifPacket,
		const Packet8d &	thenPacket,
		const Packet8d &	elsePacket
	)

pblend() [21/24]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pblend	(	const Selector< 8 > &	ifPacket,
		const Packet8f &	thenPacket,
		const Packet8f &	elsePacket
	)

pblend() [22/24]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pblend	(	const Selector< 8 > &	ifPacket,
		const Packet8s &	thenPacket,
		const Packet8s &	elsePacket
	)

pblend() [23/24]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pblend	(	const Selector< 8 > &	ifPacket,
		const Packet8us &	thenPacket,
		const Packet8us &	elsePacket
	)

pblend() [24/24]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pblend ( const Selector< unpacket_traits< Packet >::size > &  ifPacket, const Packet &  thenPacket, const Packet &  elsePacket  )

inline

pblend4()

template<typename Packet >

EIGEN_STRONG_INLINE Packet Eigen::internal::pblend4	(	const Selector< 4 > &	ifPacket,
		const Packet &	thenPacket,
		const Packet &	elsePacket
	)

pbroadcast2()

template<typename Packet >

EIGEN_DEVICE_FUNC void Eigen::internal::pbroadcast2 ( const typename unpacket_traits< Packet >::type *  a, Packet &  a0, Packet &  a1  )

inline

pbroadcast4()

template<typename Packet >

EIGEN_DEVICE_FUNC void Eigen::internal::pbroadcast4 ( const typename unpacket_traits< Packet >::type *  a, Packet &  a0, Packet &  a1, Packet &  a2, Packet &  a3  )

inline

pbroadcast4< Packet2d >() [1/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pbroadcast4< Packet2d >	(	const double *	a,
		Packet2d &	a0,
		Packet2d &	a1,
		Packet2d &	a2,
		Packet2d &	a3
	)

pbroadcast4< Packet2d >() [2/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pbroadcast4< Packet2d >	(	const double *	a,
		Packet2d &	a0,
		Packet2d &	a1,
		Packet2d &	a2,
		Packet2d &	a3
	)

pbroadcast4< Packet4f >() [1/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pbroadcast4< Packet4f >	(	const float *	a,
		Packet4f &	a0,
		Packet4f &	a1,
		Packet4f &	a2,
		Packet4f &	a3
	)

pbroadcast4< Packet4f >() [2/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pbroadcast4< Packet4f >	(	const float *	a,
		Packet4f &	a0,
		Packet4f &	a1,
		Packet4f &	a2,
		Packet4f &	a3
	)

pbroadcast4< Packet4f >() [3/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pbroadcast4< Packet4f >	(	const float *	a,
		Packet4f &	a0,
		Packet4f &	a1,
		Packet4f &	a2,
		Packet4f &	a3
	)

pbroadcast4< Packet4i >() [1/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pbroadcast4< Packet4i >	(	const int *	a,
		Packet4i &	a0,
		Packet4i &	a1,
		Packet4i &	a2,
		Packet4i &	a3
	)

pbroadcast4< Packet4i >() [2/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pbroadcast4< Packet4i >	(	const int *	a,
		Packet4i &	a0,
		Packet4i &	a1,
		Packet4i &	a2,
		Packet4i &	a3
	)

pbroadcast4_common()

template<typename Packet >

EIGEN_STRONG_INLINE void Eigen::internal::pbroadcast4_common	(	const __UNPACK_TYPE__(Packet) *	a,
		Packet &	a0,
		Packet &	a1,
		Packet &	a2,
		Packet &	a3
	)

pbroadcast4_old()

template<typename Packet >

EIGEN_ALWAYS_INLINE void Eigen::internal::pbroadcast4_old	(	const __UNPACK_TYPE__(Packet) *	a,
		Packet &	a0,
		Packet &	a1,
		Packet &	a2,
		Packet &	a3
	)

pbroadcast4_old< Packet2d >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::pbroadcast4_old< Packet2d >	(	const double *	a,
		Packet2d &	a0,
		Packet2d &	a1,
		Packet2d &	a2,
		Packet2d &	a3
	)

pcast() [1/4]

template<typename SrcPacket , typename TgtPacket >

EIGEN_DEVICE_FUNC TgtPacket Eigen::internal::pcast ( const SrcPacket &  a )

inline

pcast() [2/4]

template<typename SrcPacket , typename TgtPacket >

EIGEN_DEVICE_FUNC TgtPacket Eigen::internal::pcast ( const SrcPacket &  a, const SrcPacket &    )

inline

pcast() [3/4]

template<typename SrcPacket , typename TgtPacket >

EIGEN_DEVICE_FUNC TgtPacket Eigen::internal::pcast ( const SrcPacket &  a, const SrcPacket &  , const SrcPacket &  , const SrcPacket &    )

inline

pcast() [4/4]

template<typename SrcPacket , typename TgtPacket >

EIGEN_DEVICE_FUNC TgtPacket Eigen::internal::pcast ( const SrcPacket &  a, const SrcPacket &  , const SrcPacket &  , const SrcPacket &  , const SrcPacket &  , const SrcPacket &  , const SrcPacket &  , const SrcPacket &    )

inline

pcast< float, Packet1cf >()

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pcast< float, Packet1cf >

(

const float &

a

)

pcast< Packet16bf, Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pcast< Packet16bf, Packet16f >

(

const Packet16bf &

a

)

pcast< Packet16c, Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcast< Packet16c, Packet16c >

(

const Packet16c &

a

)

pcast< Packet16c, Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcast< Packet16c, Packet16uc >

(

const Packet16c &

a

)

pcast< Packet16c, Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pcast< Packet16c, Packet2l >

(

const Packet16c &

a

)

pcast< Packet16c, Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pcast< Packet16c, Packet2ul >

(

const Packet16c &

a

)

pcast< Packet16c, Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcast< Packet16c, Packet4f >

(

const Packet16c &

a

)

pcast< Packet16c, Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcast< Packet16c, Packet4i >

(

const Packet16c &

a

)

pcast< Packet16c, Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pcast< Packet16c, Packet4ui >

(

const Packet16c &

a

)

pcast< Packet16c, Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcast< Packet16c, Packet8s >

(

const Packet16c &

a

)

pcast< Packet16c, Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcast< Packet16c, Packet8us >

(

const Packet16c &

a

)

pcast< Packet16f, Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pcast< Packet16f, Packet16bf >

(

const Packet16f &

a

)

pcast< Packet16f, Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pcast< Packet16f, Packet16h >

(

const Packet16f &

a

)

pcast< Packet16f, Packet16i >()

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::pcast< Packet16f, Packet16i >

(

const Packet16f &

a

)

pcast< Packet16h, Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pcast< Packet16h, Packet16f >

(

const Packet16h &

a

)

pcast< Packet16i, Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pcast< Packet16i, Packet16f >

(

const Packet16i &

a

)

pcast< Packet16uc, Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcast< Packet16uc, Packet16c >

(

const Packet16uc &

a

)

pcast< Packet16uc, Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcast< Packet16uc, Packet16uc >

(

const Packet16uc &

a

)

pcast< Packet16uc, Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pcast< Packet16uc, Packet2l >

(

const Packet16uc &

a

)

pcast< Packet16uc, Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pcast< Packet16uc, Packet2ul >

(

const Packet16uc &

a

)

pcast< Packet16uc, Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcast< Packet16uc, Packet4f >

(

const Packet16uc &

a

)

pcast< Packet16uc, Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcast< Packet16uc, Packet4i >

(

const Packet16uc &

a

)

pcast< Packet16uc, Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pcast< Packet16uc, Packet4ui >

(

const Packet16uc &

a

)

pcast< Packet16uc, Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcast< Packet16uc, Packet8s >

(

const Packet16uc &

a

)

pcast< Packet16uc, Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcast< Packet16uc, Packet8us >

(

const Packet16uc &

a

)

pcast< Packet2d, Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcast< Packet2d, Packet4f >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pcast< Packet2f, Packet2cf >()

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pcast< Packet2f, Packet2cf >

(

const Packet2f &

a

)

pcast< Packet2f, Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pcast< Packet2f, Packet2f >

(

const Packet2f &

a

)

pcast< Packet2f, Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pcast< Packet2f, Packet2i >

(

const Packet2f &

a

)

pcast< Packet2f, Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pcast< Packet2f, Packet2ui >

(

const Packet2f &

a

)

pcast< Packet2f, Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pcast< Packet2f, Packet4s >	(	const Packet2f &	a,
		const Packet2f &	b
	)

pcast< Packet2f, Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pcast< Packet2f, Packet4us >	(	const Packet2f &	a,
		const Packet2f &	b
	)

pcast< Packet2f, Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pcast< Packet2f, Packet8c >	(	const Packet2f &	a,
		const Packet2f &	b,
		const Packet2f &	c,
		const Packet2f &	d
	)

pcast< Packet2f, Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pcast< Packet2f, Packet8uc >	(	const Packet2f &	a,
		const Packet2f &	b,
		const Packet2f &	c,
		const Packet2f &	d
	)

pcast< Packet2i, Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pcast< Packet2i, Packet2f >

(

const Packet2i &

a

)

pcast< Packet2i, Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pcast< Packet2i, Packet2i >

(

const Packet2i &

a

)

pcast< Packet2i, Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pcast< Packet2i, Packet2ui >

(

const Packet2i &

a

)

pcast< Packet2i, Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pcast< Packet2i, Packet4s >	(	const Packet2i &	a,
		const Packet2i &	b
	)

pcast< Packet2i, Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pcast< Packet2i, Packet4us >	(	const Packet2i &	a,
		const Packet2i &	b
	)

pcast< Packet2i, Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pcast< Packet2i, Packet8c >	(	const Packet2i &	a,
		const Packet2i &	b,
		const Packet2i &	c,
		const Packet2i &	d
	)

pcast< Packet2i, Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pcast< Packet2i, Packet8uc >	(	const Packet2i &	a,
		const Packet2i &	b,
		const Packet2i &	c,
		const Packet2i &	d
	)

pcast< Packet2l, Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::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
	)

pcast< Packet2l, Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::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
	)

pcast< Packet2l, Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pcast< Packet2l, Packet2l >

(

const Packet2l &

a

)

pcast< Packet2l, Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pcast< Packet2l, Packet2ul >

(

const Packet2l &

a

)

pcast< Packet2l, Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcast< Packet2l, Packet4f >	(	const Packet2l &	a,
		const Packet2l &	b
	)

pcast< Packet2l, Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcast< Packet2l, Packet4i >	(	const Packet2l &	a,
		const Packet2l &	b
	)

pcast< Packet2l, Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pcast< Packet2l, Packet4ui >	(	const Packet2l &	a,
		const Packet2l &	b
	)

pcast< Packet2l, Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcast< Packet2l, Packet8s >	(	const Packet2l &	a,
		const Packet2l &	b,
		const Packet2l &	c,
		const Packet2l &	d
	)

pcast< Packet2l, Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcast< Packet2l, Packet8us >	(	const Packet2l &	a,
		const Packet2l &	b,
		const Packet2l &	c,
		const Packet2l &	d
	)

pcast< Packet2ui, Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pcast< Packet2ui, Packet2f >

(

const Packet2ui &

a

)

pcast< Packet2ui, Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pcast< Packet2ui, Packet2i >

(

const Packet2ui &

a

)

pcast< Packet2ui, Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pcast< Packet2ui, Packet2ui >

(

const Packet2ui &

a

)

pcast< Packet2ui, Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pcast< Packet2ui, Packet4s >	(	const Packet2ui &	a,
		const Packet2ui &	b
	)

pcast< Packet2ui, Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pcast< Packet2ui, Packet4us >	(	const Packet2ui &	a,
		const Packet2ui &	b
	)

pcast< Packet2ui, Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pcast< Packet2ui, Packet8c >	(	const Packet2ui &	a,
		const Packet2ui &	b,
		const Packet2ui &	c,
		const Packet2ui &	d
	)

pcast< Packet2ui, Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pcast< Packet2ui, Packet8uc >	(	const Packet2ui &	a,
		const Packet2ui &	b,
		const Packet2ui &	c,
		const Packet2ui &	d
	)

pcast< Packet2ul, Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::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
	)

pcast< Packet2ul, Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::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
	)

pcast< Packet2ul, Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pcast< Packet2ul, Packet2l >

(

const Packet2ul &

a

)

pcast< Packet2ul, Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pcast< Packet2ul, Packet2ul >

(

const Packet2ul &

a

)

pcast< Packet2ul, Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcast< Packet2ul, Packet4f >	(	const Packet2ul &	a,
		const Packet2ul &	b
	)

pcast< Packet2ul, Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcast< Packet2ul, Packet4i >	(	const Packet2ul &	a,
		const Packet2ul &	b
	)

pcast< Packet2ul, Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pcast< Packet2ul, Packet4ui >	(	const Packet2ul &	a,
		const Packet2ul &	b
	)

pcast< Packet2ul, Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcast< Packet2ul, Packet8s >	(	const Packet2ul &	a,
		const Packet2ul &	b,
		const Packet2ul &	c,
		const Packet2ul &	d
	)

pcast< Packet2ul, Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcast< Packet2ul, Packet8us >	(	const Packet2ul &	a,
		const Packet2ul &	b,
		const Packet2ul &	c,
		const Packet2ul &	d
	)

pcast< Packet4c, Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pcast< Packet4c, Packet4c >

(

const Packet4c &

a

)

pcast< Packet4c, Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pcast< Packet4c, Packet4uc >

(

const Packet4c &

a

)

pcast< Packet4f, Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcast< Packet4f, Packet16c >	(	const Packet4f &	a,
		const Packet4f &	b,
		const Packet4f &	c,
		const Packet4f &	d
	)

pcast< Packet4f, Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcast< Packet4f, Packet16uc >	(	const Packet4f &	a,
		const Packet4f &	b,
		const Packet4f &	c,
		const Packet4f &	d
	)

pcast< Packet4f, Packet2d >()

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pcast< Packet4f, Packet2d >

(

const Packet4f &

a

)

pcast< Packet4f, Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pcast< Packet4f, Packet2l >

(

const Packet4f &

a

)

pcast< Packet4f, Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pcast< Packet4f, Packet2ul >

(

const Packet4f &

a

)

pcast< Packet4f, Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcast< Packet4f, Packet4f >

(

const Packet4f &

a

)

pcast< Packet4f, Packet4i >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcast< Packet4f, Packet4i >

(

const Packet4f &

a

)

pcast< Packet4f, Packet4i >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcast< Packet4f, Packet4i >

(

const Packet4f &

a

)

pcast< Packet4f, Packet4i >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcast< Packet4f, Packet4i >

(

const Packet4f &

a

)

pcast< Packet4f, Packet4ui >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pcast< Packet4f, Packet4ui >

(

const Packet4f &

a

)

pcast< Packet4f, Packet4ui >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pcast< Packet4f, Packet4ui >

(

const Packet4f &

a

)

pcast< Packet4f, Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcast< Packet4f, Packet8s >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pcast< Packet4f, Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcast< Packet4f, Packet8us >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pcast< Packet4i, Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcast< Packet4i, Packet16c >	(	const Packet4i &	a,
		const Packet4i &	b,
		const Packet4i &	c,
		const Packet4i &	d
	)

pcast< Packet4i, Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcast< Packet4i, Packet16uc >	(	const Packet4i &	a,
		const Packet4i &	b,
		const Packet4i &	c,
		const Packet4i &	d
	)

pcast< Packet4i, Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pcast< Packet4i, Packet2l >

(

const Packet4i &

a

)

pcast< Packet4i, Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pcast< Packet4i, Packet2ul >

(

const Packet4i &

a

)

pcast< Packet4i, Packet4f >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcast< Packet4i, Packet4f >

(

const Packet4i &

a

)

pcast< Packet4i, Packet4f >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcast< Packet4i, Packet4f >

(

const Packet4i &

a

)

pcast< Packet4i, Packet4f >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcast< Packet4i, Packet4f >

(

const Packet4i &

a

)

pcast< Packet4i, Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcast< Packet4i, Packet4i >

(

const Packet4i &

a

)

pcast< Packet4i, Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pcast< Packet4i, Packet4ui >

(

const Packet4i &

a

)

pcast< Packet4i, Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcast< Packet4i, Packet8s >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pcast< Packet4i, Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcast< Packet4i, Packet8us >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pcast< Packet4s, Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pcast< Packet4s, Packet2f >

(

const Packet4s &

a

)

pcast< Packet4s, Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pcast< Packet4s, Packet2i >

(

const Packet4s &

a

)

pcast< Packet4s, Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pcast< Packet4s, Packet2ui >

(

const Packet4s &

a

)

pcast< Packet4s, Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pcast< Packet4s, Packet4s >

(

const Packet4s &

a

)

pcast< Packet4s, Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pcast< Packet4s, Packet4us >

(

const Packet4s &

a

)

pcast< Packet4s, Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pcast< Packet4s, Packet8c >	(	const Packet4s &	a,
		const Packet4s &	b
	)

pcast< Packet4s, Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pcast< Packet4s, Packet8uc >	(	const Packet4s &	a,
		const Packet4s &	b
	)

pcast< Packet4uc, Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pcast< Packet4uc, Packet4c >

(

const Packet4uc &

a

)

pcast< Packet4uc, Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pcast< Packet4uc, Packet4uc >

(

const Packet4uc &

a

)

pcast< Packet4ui, Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcast< Packet4ui, Packet16c >	(	const Packet4ui &	a,
		const Packet4ui &	b,
		const Packet4ui &	c,
		const Packet4ui &	d
	)

pcast< Packet4ui, Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcast< Packet4ui, Packet16uc >	(	const Packet4ui &	a,
		const Packet4ui &	b,
		const Packet4ui &	c,
		const Packet4ui &	d
	)

pcast< Packet4ui, Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pcast< Packet4ui, Packet2l >

(

const Packet4ui &

a

)

pcast< Packet4ui, Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pcast< Packet4ui, Packet2ul >

(

const Packet4ui &

a

)

pcast< Packet4ui, Packet4f >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcast< Packet4ui, Packet4f >

(

const Packet4ui &

a

)

pcast< Packet4ui, Packet4f >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcast< Packet4ui, Packet4f >

(

const Packet4ui &

a

)

pcast< Packet4ui, Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcast< Packet4ui, Packet4i >

(

const Packet4ui &

a

)

pcast< Packet4ui, Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pcast< Packet4ui, Packet4ui >

(

const Packet4ui &

a

)

pcast< Packet4ui, Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcast< Packet4ui, Packet8s >	(	const Packet4ui &	a,
		const Packet4ui &	b
	)

pcast< Packet4ui, Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcast< Packet4ui, Packet8us >	(	const Packet4ui &	a,
		const Packet4ui &	b
	)

pcast< Packet4us, Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pcast< Packet4us, Packet2f >

(

const Packet4us &

a

)

pcast< Packet4us, Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pcast< Packet4us, Packet2i >

(

const Packet4us &

a

)

pcast< Packet4us, Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pcast< Packet4us, Packet2ui >

(

const Packet4us &

a

)

pcast< Packet4us, Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pcast< Packet4us, Packet4s >

(

const Packet4us &

a

)

pcast< Packet4us, Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pcast< Packet4us, Packet4us >

(

const Packet4us &

a

)

pcast< Packet4us, Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pcast< Packet4us, Packet8c >	(	const Packet4us &	a,
		const Packet4us &	b
	)

pcast< Packet4us, Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pcast< Packet4us, Packet8uc >	(	const Packet4us &	a,
		const Packet4us &	b
	)

pcast< Packet8bf, Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pcast< Packet8bf, Packet8f >

(

const Packet8bf &

a

)

pcast< Packet8bf, Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcast< Packet8bf, Packet8us >

(

const Packet8bf &

a

)

pcast< Packet8c, Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pcast< Packet8c, Packet2f >

(

const Packet8c &

a

)

pcast< Packet8c, Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pcast< Packet8c, Packet2i >

(

const Packet8c &

a

)

pcast< Packet8c, Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pcast< Packet8c, Packet2ui >

(

const Packet8c &

a

)

pcast< Packet8c, Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pcast< Packet8c, Packet4s >

(

const Packet8c &

a

)

pcast< Packet8c, Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pcast< Packet8c, Packet4us >

(

const Packet8c &

a

)

pcast< Packet8c, Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pcast< Packet8c, Packet8c >

(

const Packet8c &

a

)

pcast< Packet8c, Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pcast< Packet8c, Packet8uc >

(

const Packet8c &

a

)

pcast< Packet8f, Packet8bf >()

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pcast< Packet8f, Packet8bf >

(

const Packet8f &

a

)

pcast< Packet8f, Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pcast< Packet8f, Packet8h >

(

const Packet8f &

a

)

pcast< Packet8f, Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::pcast< Packet8f, Packet8i >

(

const Packet8f &

a

)

pcast< Packet8h, Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pcast< Packet8h, Packet8f >

(

const Packet8h &

a

)

pcast< Packet8i, Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pcast< Packet8i, Packet8f >

(

const Packet8i &

a

)

pcast< Packet8s, Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcast< Packet8s, Packet16c >	(	const Packet8s &	a,
		const Packet8s &	b
	)

pcast< Packet8s, Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcast< Packet8s, Packet16uc >	(	const Packet8s &	a,
		const Packet8s &	b
	)

pcast< Packet8s, Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pcast< Packet8s, Packet2l >

(

const Packet8s &

a

)

pcast< Packet8s, Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pcast< Packet8s, Packet2ul >

(

const Packet8s &

a

)

pcast< Packet8s, Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcast< Packet8s, Packet4f >

(

const Packet8s &

a

)

pcast< Packet8s, Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcast< Packet8s, Packet4i >

(

const Packet8s &

a

)

pcast< Packet8s, Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pcast< Packet8s, Packet4ui >

(

const Packet8s &

a

)

pcast< Packet8s, Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcast< Packet8s, Packet8s >

(

const Packet8s &

a

)

pcast< Packet8s, Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcast< Packet8s, Packet8us >

(

const Packet8s &

a

)

pcast< Packet8uc, Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pcast< Packet8uc, Packet2f >

(

const Packet8uc &

a

)

pcast< Packet8uc, Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pcast< Packet8uc, Packet2i >

(

const Packet8uc &

a

)

pcast< Packet8uc, Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pcast< Packet8uc, Packet2ui >

(

const Packet8uc &

a

)

pcast< Packet8uc, Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pcast< Packet8uc, Packet4s >

(

const Packet8uc &

a

)

pcast< Packet8uc, Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pcast< Packet8uc, Packet4us >

(

const Packet8uc &

a

)

pcast< Packet8uc, Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pcast< Packet8uc, Packet8c >

(

const Packet8uc &

a

)

pcast< Packet8uc, Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pcast< Packet8uc, Packet8uc >

(

const Packet8uc &

a

)

pcast< Packet8us, Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcast< Packet8us, Packet16c >	(	const Packet8us &	a,
		const Packet8us &	b
	)

pcast< Packet8us, Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcast< Packet8us, Packet16uc >	(	const Packet8us &	a,
		const Packet8us &	b
	)

pcast< Packet8us, Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pcast< Packet8us, Packet2l >

(

const Packet8us &

a

)

pcast< Packet8us, Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pcast< Packet8us, Packet2ul >

(

const Packet8us &

a

)

pcast< Packet8us, Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcast< Packet8us, Packet4f >

(

const Packet8us &

a

)

pcast< Packet8us, Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcast< Packet8us, Packet4i >

(

const Packet8us &

a

)

pcast< Packet8us, Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pcast< Packet8us, Packet4ui >

(

const Packet8us &

a

)

pcast< Packet8us, Packet8bf >()

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pcast< Packet8us, Packet8bf >

(

const Packet8us &

a

)

pcast< Packet8us, Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcast< Packet8us, Packet8s >

(

const Packet8us &

a

)

pcast< Packet8us, Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcast< Packet8us, Packet8us >

(

const Packet8us &

a

)

pcast< PacketXf, PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pcast< PacketXf, PacketXi >

(

const PacketXf &

a

)

pcast< PacketXi, PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pcast< PacketXi, PacketXf >

(

const PacketXi &

a

)

pceil()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pceil

(

const Packet &

a

)

pceil< Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pceil< Packet16bf >

(

const Packet16bf &

a

)

pceil< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pceil< Packet16f >

(

const Packet16f &

a

)

pceil< Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pceil< Packet16h >

(

const Packet16h &

a

)

pceil< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pceil< Packet2d >

(

const Packet2d &

a

)

pceil< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pceil< Packet2d >

(

const Packet2d &

a

)

pceil< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pceil< Packet2d >

(

const Packet2d &

a

)

pceil< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pceil< Packet2f >

(

const Packet2f &

a

)

pceil< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pceil< Packet4bf >

(

const Packet4bf &

a

)

pceil< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pceil< Packet4d >

(

const Packet4d &

a

)

pceil< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pceil< Packet4f >

(

const Packet4f &

a

)

pceil< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pceil< Packet4f >

(

const Packet4f &

a

)

pceil< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pceil< Packet4f >

(

const Packet4f &

a

)

pceil< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pceil< Packet4f >

(

const Packet4f &

a

)

pceil< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pceil< Packet4f >

(

const Packet4f &

a

)

pceil< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pceil< Packet8bf >

(

const Packet8bf &

a

)

pceil< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pceil< Packet8bf >

(

const Packet8bf &

a

)

pceil< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pceil< Packet8d >

(

const Packet8d &

a

)

pceil< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pceil< Packet8f >

(

const Packet8f &

a

)

pceil< Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pceil< Packet8h >

(

const Packet8h &

a

)

pcmp_eq() [1/33]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pcmp_eq ( const Packet &  a, const Packet &  b  )

inline

pcmp_eq() [2/33]

template<>

EIGEN_STRONG_INLINE Packet16b Eigen::internal::pcmp_eq	(	const Packet16b &	a,
		const Packet16b &	b
	)

pcmp_eq() [3/33]

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pcmp_eq	(	const Packet16bf &	a,
		const Packet16bf &	b
	)

pcmp_eq() [4/33]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcmp_eq	(	const Packet16c &	a,
		const Packet16c &	b
	)

pcmp_eq() [5/33]

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pcmp_eq	(	const Packet16f &	a,
		const Packet16f &	b
	)

pcmp_eq() [6/33]

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pcmp_eq	(	const Packet16h &	a,
		const Packet16h &	b
	)

pcmp_eq() [7/33]

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::pcmp_eq	(	const Packet16i &	a,
		const Packet16i &	b
	)

pcmp_eq() [8/33]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcmp_eq	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

pcmp_eq() [9/33]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pcmp_eq	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

pcmp_eq() [10/33]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pcmp_eq	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

pcmp_eq() [11/33]

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pcmp_eq	(	const Packet1cf &	a,
		const Packet1cf &	b
	)

pcmp_eq() [12/33]

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pcmp_eq	(	const Packet2cd &	a,
		const Packet2cd &	b
	)

pcmp_eq() [13/33]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pcmp_eq	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pcmp_eq() [14/33]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pcmp_eq	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pcmp_eq() [15/33]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pcmp_eq	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pcmp_eq() [16/33]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pcmp_eq	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pcmp_eq() [17/33]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pcmp_eq	(	const Packet2d &	a,
		const Packet2d &	b
	)

pcmp_eq() [18/33]

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pcmp_eq	(	const Packet4cd &	a,
		const Packet4cd &	b
	)

pcmp_eq() [19/33]

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pcmp_eq	(	const Packet4cf &	a,
		const Packet4cf &	b
	)

pcmp_eq() [20/33]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pcmp_eq	(	const Packet4d &	a,
		const Packet4d &	b
	)

pcmp_eq() [21/33]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_eq	(	const Packet4f &	a,
		const Packet4f &	b
	)

pcmp_eq() [22/33]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_eq	(	const Packet4f &	a,
		const Packet4f &	b
	)

pcmp_eq() [23/33]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_eq	(	const Packet4i &	a,
		const Packet4i &	b
	)

pcmp_eq() [24/33]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_eq	(	const Packet4i &	a,
		const Packet4i &	b
	)

pcmp_eq() [25/33]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pcmp_eq	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pcmp_eq() [26/33]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pcmp_eq	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pcmp_eq() [27/33]

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pcmp_eq	(	const Packet8cf &	a,
		const Packet8cf &	b
	)

pcmp_eq() [28/33]

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pcmp_eq	(	const Packet8d &	a,
		const Packet8d &	b
	)

pcmp_eq() [29/33]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pcmp_eq	(	const Packet8f &	a,
		const Packet8f &	b
	)

pcmp_eq() [30/33]

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pcmp_eq	(	const Packet8h &	a,
		const Packet8h &	b
	)

pcmp_eq() [31/33]

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::pcmp_eq	(	const Packet8i &	a,
		const Packet8i &	b
	)

pcmp_eq() [32/33]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcmp_eq	(	const Packet8s &	a,
		const Packet8s &	b
	)

pcmp_eq() [33/33]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcmp_eq	(	const Packet8us &	a,
		const Packet8us &	b
	)

pcmp_eq< Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcmp_eq< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

pcmp_eq< Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcmp_eq< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

pcmp_eq< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pcmp_eq< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

pcmp_eq< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pcmp_eq< Packet2i >	(	const Packet2i &	a,
		const Packet2i &	b
	)

pcmp_eq< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pcmp_eq< Packet2l >	(	const Packet2l &	a,
		const Packet2l &	b
	)

pcmp_eq< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pcmp_eq< Packet2ui >	(	const Packet2ui &	a,
		const Packet2ui &	b
	)

pcmp_eq< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pcmp_eq< Packet2ul >	(	const Packet2ul &	a,
		const Packet2ul &	b
	)

pcmp_eq< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pcmp_eq< Packet4bf >	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

pcmp_eq< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pcmp_eq< Packet4c >	(	const Packet4c &	a,
		const Packet4c &	b
	)

pcmp_eq< Packet4f >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_eq< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pcmp_eq< Packet4f >() [2/2]

template<>

Packet4f EIGEN_STRONG_INLINE Eigen::internal::pcmp_eq< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pcmp_eq< Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_eq< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pcmp_eq< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pcmp_eq< Packet4s >	(	const Packet4s &	a,
		const Packet4s &	b
	)

pcmp_eq< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pcmp_eq< Packet4uc >	(	const Packet4uc &	a,
		const Packet4uc &	b
	)

pcmp_eq< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pcmp_eq< Packet4ui >	(	const Packet4ui &	a,
		const Packet4ui &	b
	)

pcmp_eq< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pcmp_eq< Packet4us >	(	const Packet4us &	a,
		const Packet4us &	b
	)

pcmp_eq< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pcmp_eq< Packet8c >	(	const Packet8c &	a,
		const Packet8c &	b
	)

pcmp_eq< Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcmp_eq< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

pcmp_eq< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pcmp_eq< Packet8uc >	(	const Packet8uc &	a,
		const Packet8uc &	b
	)

pcmp_eq< Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcmp_eq< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

pcmp_eq< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pcmp_eq< PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

pcmp_eq< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pcmp_eq< PacketXi >	(	const PacketXi &	a,
		const PacketXi &	b
	)

pcmp_le() [1/19]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pcmp_le ( const Packet &  a, const Packet &  b  )

inline

pcmp_le() [2/19]

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pcmp_le	(	const Packet16bf &	a,
		const Packet16bf &	b
	)

pcmp_le() [3/19]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcmp_le	(	const Packet16c &	a,
		const Packet16c &	b
	)

pcmp_le() [4/19]

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pcmp_le	(	const Packet16f &	a,
		const Packet16f &	b
	)

pcmp_le() [5/19]

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pcmp_le	(	const Packet16h &	a,
		const Packet16h &	b
	)

pcmp_le() [6/19]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcmp_le	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

pcmp_le() [7/19]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pcmp_le	(	const Packet2d &	a,
		const Packet2d &	b
	)

pcmp_le() [8/19]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pcmp_le	(	const Packet4d &	a,
		const Packet4d &	b
	)

pcmp_le() [9/19]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_le	(	const Packet4f &	a,
		const Packet4f &	b
	)

pcmp_le() [10/19]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_le	(	const Packet4f &	a,
		const Packet4f &	b
	)

pcmp_le() [11/19]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_le	(	const Packet4i &	a,
		const Packet4i &	b
	)

pcmp_le() [12/19]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_le	(	const Packet4i &	a,
		const Packet4i &	b
	)

pcmp_le() [13/19]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pcmp_le	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pcmp_le() [14/19]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pcmp_le	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pcmp_le() [15/19]

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pcmp_le	(	const Packet8d &	a,
		const Packet8d &	b
	)

pcmp_le() [16/19]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pcmp_le	(	const Packet8f &	a,
		const Packet8f &	b
	)

pcmp_le() [17/19]

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pcmp_le	(	const Packet8h &	a,
		const Packet8h &	b
	)

pcmp_le() [18/19]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcmp_le	(	const Packet8s &	a,
		const Packet8s &	b
	)

pcmp_le() [19/19]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcmp_le	(	const Packet8us &	a,
		const Packet8us &	b
	)

pcmp_le< Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcmp_le< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

pcmp_le< Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcmp_le< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

pcmp_le< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pcmp_le< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

pcmp_le< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pcmp_le< Packet2i >	(	const Packet2i &	a,
		const Packet2i &	b
	)

pcmp_le< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pcmp_le< Packet2l >	(	const Packet2l &	a,
		const Packet2l &	b
	)

pcmp_le< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pcmp_le< Packet2ui >	(	const Packet2ui &	a,
		const Packet2ui &	b
	)

pcmp_le< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pcmp_le< Packet2ul >	(	const Packet2ul &	a,
		const Packet2ul &	b
	)

pcmp_le< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pcmp_le< Packet4bf >	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

pcmp_le< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pcmp_le< Packet4c >	(	const Packet4c &	a,
		const Packet4c &	b
	)

pcmp_le< Packet4f >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_le< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pcmp_le< Packet4f >() [2/2]

template<>

Packet4f EIGEN_STRONG_INLINE Eigen::internal::pcmp_le< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pcmp_le< Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_le< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pcmp_le< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pcmp_le< Packet4s >	(	const Packet4s &	a,
		const Packet4s &	b
	)

pcmp_le< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pcmp_le< Packet4uc >	(	const Packet4uc &	a,
		const Packet4uc &	b
	)

pcmp_le< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pcmp_le< Packet4ui >	(	const Packet4ui &	a,
		const Packet4ui &	b
	)

pcmp_le< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pcmp_le< Packet4us >	(	const Packet4us &	a,
		const Packet4us &	b
	)

pcmp_le< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pcmp_le< Packet8c >	(	const Packet8c &	a,
		const Packet8c &	b
	)

pcmp_le< Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcmp_le< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

pcmp_le< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pcmp_le< Packet8uc >	(	const Packet8uc &	a,
		const Packet8uc &	b
	)

pcmp_le< Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcmp_le< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

pcmp_le< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pcmp_le< PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

pcmp_le< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pcmp_le< PacketXi >	(	const PacketXi &	a,
		const PacketXi &	b
	)

pcmp_lt() [1/19]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pcmp_lt ( const Packet &  a, const Packet &  b  )

inline

pcmp_lt() [2/19]

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pcmp_lt	(	const Packet16bf &	a,
		const Packet16bf &	b
	)

pcmp_lt() [3/19]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcmp_lt	(	const Packet16c &	a,
		const Packet16c &	b
	)

pcmp_lt() [4/19]

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pcmp_lt	(	const Packet16f &	a,
		const Packet16f &	b
	)

pcmp_lt() [5/19]

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pcmp_lt	(	const Packet16h &	a,
		const Packet16h &	b
	)

pcmp_lt() [6/19]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcmp_lt	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

pcmp_lt() [7/19]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pcmp_lt	(	const Packet2d &	a,
		const Packet2d &	b
	)

pcmp_lt() [8/19]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pcmp_lt	(	const Packet4d &	a,
		const Packet4d &	b
	)

pcmp_lt() [9/19]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_lt	(	const Packet4f &	a,
		const Packet4f &	b
	)

pcmp_lt() [10/19]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_lt	(	const Packet4f &	a,
		const Packet4f &	b
	)

pcmp_lt() [11/19]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_lt	(	const Packet4i &	a,
		const Packet4i &	b
	)

pcmp_lt() [12/19]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_lt	(	const Packet4i &	a,
		const Packet4i &	b
	)

pcmp_lt() [13/19]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pcmp_lt	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pcmp_lt() [14/19]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pcmp_lt	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pcmp_lt() [15/19]

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pcmp_lt	(	const Packet8d &	a,
		const Packet8d &	b
	)

pcmp_lt() [16/19]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pcmp_lt	(	const Packet8f &	a,
		const Packet8f &	b
	)

pcmp_lt() [17/19]

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pcmp_lt	(	const Packet8h &	a,
		const Packet8h &	b
	)

pcmp_lt() [18/19]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcmp_lt	(	const Packet8s &	a,
		const Packet8s &	b
	)

pcmp_lt() [19/19]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcmp_lt	(	const Packet8us &	a,
		const Packet8us &	b
	)

pcmp_lt< Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcmp_lt< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

pcmp_lt< Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcmp_lt< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

pcmp_lt< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pcmp_lt< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

pcmp_lt< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pcmp_lt< Packet2i >	(	const Packet2i &	a,
		const Packet2i &	b
	)

pcmp_lt< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pcmp_lt< Packet2l >	(	const Packet2l &	a,
		const Packet2l &	b
	)

pcmp_lt< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pcmp_lt< Packet2ui >	(	const Packet2ui &	a,
		const Packet2ui &	b
	)

pcmp_lt< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pcmp_lt< Packet2ul >	(	const Packet2ul &	a,
		const Packet2ul &	b
	)

pcmp_lt< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pcmp_lt< Packet4bf >	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

pcmp_lt< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pcmp_lt< Packet4c >	(	const Packet4c &	a,
		const Packet4c &	b
	)

pcmp_lt< Packet4f >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_lt< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pcmp_lt< Packet4f >() [2/2]

template<>

Packet4f EIGEN_STRONG_INLINE Eigen::internal::pcmp_lt< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pcmp_lt< Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_lt< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pcmp_lt< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pcmp_lt< Packet4s >	(	const Packet4s &	a,
		const Packet4s &	b
	)

pcmp_lt< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pcmp_lt< Packet4uc >	(	const Packet4uc &	a,
		const Packet4uc &	b
	)

pcmp_lt< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pcmp_lt< Packet4ui >	(	const Packet4ui &	a,
		const Packet4ui &	b
	)

pcmp_lt< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pcmp_lt< Packet4us >	(	const Packet4us &	a,
		const Packet4us &	b
	)

pcmp_lt< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pcmp_lt< Packet8c >	(	const Packet8c &	a,
		const Packet8c &	b
	)

pcmp_lt< Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcmp_lt< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

pcmp_lt< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pcmp_lt< Packet8uc >	(	const Packet8uc &	a,
		const Packet8uc &	b
	)

pcmp_lt< Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcmp_lt< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

pcmp_lt< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pcmp_lt< PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

pcmp_lt< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pcmp_lt< PacketXi >	(	const PacketXi &	a,
		const PacketXi &	b
	)

pcmp_lt_or_nan() [1/13]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pcmp_lt_or_nan ( const Packet &  a, const Packet &  b  )

inline

pcmp_lt_or_nan() [2/13]

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pcmp_lt_or_nan	(	const Packet16bf &	a,
		const Packet16bf &	b
	)

pcmp_lt_or_nan() [3/13]

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pcmp_lt_or_nan	(	const Packet16f &	a,
		const Packet16f &	b
	)

pcmp_lt_or_nan() [4/13]

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pcmp_lt_or_nan	(	const Packet16h &	a,
		const Packet16h &	b
	)

pcmp_lt_or_nan() [5/13]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pcmp_lt_or_nan	(	const Packet2d &	a,
		const Packet2d &	b
	)

pcmp_lt_or_nan() [6/13]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pcmp_lt_or_nan	(	const Packet4d &	a,
		const Packet4d &	b
	)

pcmp_lt_or_nan() [7/13]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_lt_or_nan	(	const Packet4f &	a,
		const Packet4f &	b
	)

pcmp_lt_or_nan() [8/13]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_lt_or_nan	(	const Packet4f &	a,
		const Packet4f &	b
	)

pcmp_lt_or_nan() [9/13]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pcmp_lt_or_nan	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pcmp_lt_or_nan() [10/13]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pcmp_lt_or_nan	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pcmp_lt_or_nan() [11/13]

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pcmp_lt_or_nan	(	const Packet8d &	a,
		const Packet8d &	b
	)

pcmp_lt_or_nan() [12/13]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pcmp_lt_or_nan	(	const Packet8f &	a,
		const Packet8f &	b
	)

pcmp_lt_or_nan() [13/13]

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pcmp_lt_or_nan	(	const Packet8h &	a,
		const Packet8h &	b
	)

pcmp_lt_or_nan< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pcmp_lt_or_nan< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

pcmp_lt_or_nan< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pcmp_lt_or_nan< Packet4bf >	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

pcmp_lt_or_nan< Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_lt_or_nan< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pcmp_lt_or_nan< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pcmp_lt_or_nan< PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

pconj() [1/55]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pconj ( const Packet &  a )

inline

pconj() [2/55]

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pconj

(

const Packet16bf &

a

)

pconj() [3/55]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pconj

(

const Packet16c &

a

)

pconj() [4/55]

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pconj

(

const Packet16f &

a

)

pconj() [5/55]

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pconj

(

const Packet16h &

a

)

pconj() [6/55]

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::pconj

(

const Packet16i &

a

)

pconj() [7/55]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pconj

(

const Packet16uc &

a

)

pconj() [8/55]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pconj

(

const Packet1cd &

a

)

pconj() [9/55]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pconj

(

const Packet1cd &

a

)

pconj() [10/55]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pconj

(

const Packet1cd &

a

)

pconj() [11/55]

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pconj

(

const Packet1cf &

a

)

pconj() [12/55]

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pconj

(

const Packet2cd &

a

)

pconj() [13/55]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pconj

(

const Packet2cf &

a

)

pconj() [14/55]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pconj

(

const Packet2cf &

a

)

pconj() [15/55]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pconj

(

const Packet2cf &

a

)

pconj() [16/55]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pconj

(

const Packet2cf &

a

)

pconj() [17/55]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pconj

(

const Packet2cf &

a

)

pconj() [18/55]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pconj

(

const Packet2d &

a

)

pconj() [19/55]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pconj

(

const Packet2d &

a

)

pconj() [20/55]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pconj

(

const Packet2d &

a

)

pconj() [21/55]

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pconj

(

const Packet2f &

a

)

pconj() [22/55]

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pconj

(

const Packet2i &

a

)

pconj() [23/55]

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pconj

(

const Packet2l &

a

)

pconj() [24/55]

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pconj

(

const Packet2ui &

a

)

pconj() [25/55]

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pconj

(

const Packet2ul &

a

)

pconj() [26/55]

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pconj

(

const Packet4bf &

a

)

pconj() [27/55]

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pconj

(

const Packet4c &

a

)

pconj() [28/55]

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pconj

(

const Packet4cd &

a

)

pconj() [29/55]

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pconj

(

const Packet4cf &

a

)

pconj() [30/55]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pconj

(

const Packet4d &

a

)

pconj() [31/55]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pconj

(

const Packet4f &

a

)

pconj() [32/55]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pconj

(

const Packet4f &

a

)

pconj() [33/55]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pconj

(

const Packet4f &

a

)

pconj() [34/55]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pconj

(

const Packet4f &

a

)

pconj() [35/55]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pconj

(

const Packet4i &

a

)

pconj() [36/55]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pconj

(

const Packet4i &

a

)

pconj() [37/55]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pconj

(

const Packet4i &

a

)

pconj() [38/55]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pconj

(

const Packet4i &

a

)

pconj() [39/55]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pconj

(

const Packet4i &

a

)

pconj() [40/55]

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pconj

(

const Packet4s &

a

)

pconj() [41/55]

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pconj

(

const Packet4uc &

a

)

pconj() [42/55]

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pconj

(

const Packet4ui &

a

)

pconj() [43/55]

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pconj

(

const Packet4us &

a

)

pconj() [44/55]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pconj

(

const Packet8bf &

a

)

pconj() [45/55]

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pconj

(

const Packet8c &

a

)

pconj() [46/55]

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pconj

(

const Packet8cf &

a

)

pconj() [47/55]

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pconj

(

const Packet8d &

a

)

pconj() [48/55]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pconj

(

const Packet8f &

a

)

pconj() [49/55]

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pconj

(

const Packet8h &

a

)

pconj() [50/55]

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::pconj

(

const Packet8i &

a

)

pconj() [51/55]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pconj

(

const Packet8s &

a

)

pconj() [52/55]

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pconj

(

const Packet8uc &

a

)

pconj() [53/55]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pconj

(

const Packet8us &

a

)

pconj() [54/55]

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pconj

(

const PacketXf &

a

)

pconj() [55/55]

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pconj

(

const PacketXi &

a

)

pcos()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pcos

(

const Packet &

a

)

pcos< Packet16f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f Eigen::internal::pcos< Packet16f >

(

const Packet16f &

_x

)

pcos< Packet2f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f Eigen::internal::pcos< Packet2f >

(

const Packet2f &

x

)

pcos< Packet4f >() [1/4]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::pcos< Packet4f >

(

const Packet4f &

_x

)

pcos< Packet4f >() [2/4]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::pcos< Packet4f >

(

const Packet4f &

_x

)

pcos< Packet4f >() [3/4]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::pcos< Packet4f >

(

const Packet4f &

x

)

pcos< Packet4f >() [4/4]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::pcos< Packet4f >

(

const Packet4f &

x

)

pcos< Packet8bf >()

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pcos< Packet8bf >

(

const Packet8bf &

a

)

pcos< Packet8f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f Eigen::internal::pcos< Packet8f >

(

const Packet8f &

_x

)

pcos< PacketXf >()

template<>

EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf Eigen::internal::pcos< PacketXf >

(

const PacketXf &

x

)

pcos_float()

template<typename Packet >

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::pcos_float

(

const Packet &

x

)

pcosh()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pcosh

(

const Packet &

a

)

pcplxflip() [1/3]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pcplxflip ( const Packet &  a )

inline

pcplxflip() [2/3]

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pcplxflip

(

const Packet1cd &

x

)

pcplxflip() [3/3]

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pcplxflip

(

const Packet2cf &

x

)

pcplxflip< Packet1cf >()

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pcplxflip< Packet1cf >

(

const Packet1cf &

a

)

pcplxflip< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pcplxflip< Packet2cd >

(

const Packet2cd &

x

)

pcplxflip< Packet2cf >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pcplxflip< Packet2cf >

(

const Packet2cf &

a

)

pcplxflip< Packet2cf >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pcplxflip< Packet2cf >

(

const Packet2cf &

a

)

pcplxflip< Packet2cf >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pcplxflip< Packet2cf >

(

const Packet2cf &

x

)

pcplxflip< Packet4cd >()

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pcplxflip< Packet4cd >

(

const Packet4cd &

x

)

pcplxflip< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pcplxflip< Packet4cf >

(

const Packet4cf &

x

)

pcplxflip< Packet8cf >()

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pcplxflip< Packet8cf >

(

const Packet8cf &

x

)

pdigamma()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pdigamma

(

const Packet &

a

)

pdiv()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pdiv ( const Packet &  a, const Packet &  b  )

inline

pdiv< Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pdiv< Packet16bf >	(	const Packet16bf &	a,
		const Packet16bf &	b
	)

pdiv< Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pdiv< Packet16c >	(	const Packet16c &	,
		const Packet16c &
	)

pdiv< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pdiv< Packet16f >	(	const Packet16f &	a,
		const Packet16f &	b
	)

pdiv< Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pdiv< Packet16h >	(	const Packet16h &	a,
		const Packet16h &	b
	)

pdiv< Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pdiv< Packet16uc >	(	const Packet16uc &	,
		const Packet16uc &
	)

pdiv< Packet1cd >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pdiv< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

pdiv< Packet1cd >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pdiv< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

pdiv< Packet1cd >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pdiv< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

pdiv< Packet1cf >()

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pdiv< Packet1cf >	(	const Packet1cf &	a,
		const Packet1cf &	b
	)

pdiv< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pdiv< Packet2cd >	(	const Packet2cd &	a,
		const Packet2cd &	b
	)

pdiv< Packet2cf >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pdiv< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pdiv< Packet2cf >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pdiv< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pdiv< Packet2cf >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pdiv< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pdiv< Packet2cf >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pdiv< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pdiv< Packet2cf >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pdiv< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pdiv< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pdiv< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pdiv< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pdiv< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pdiv< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pdiv< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pdiv< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pdiv< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

pdiv< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pdiv< Packet2i >	(	const Packet2i &	,
		const Packet2i &
	)

pdiv< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pdiv< Packet2l >	(	const Packet2l &	,
		const Packet2l &
	)

pdiv< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pdiv< Packet2ui >	(	const Packet2ui &	,
		const Packet2ui &
	)

pdiv< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pdiv< Packet2ul >	(	const Packet2ul &	,
		const Packet2ul &
	)

pdiv< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pdiv< Packet4bf >	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

pdiv< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pdiv< Packet4c >	(	const Packet4c &	,
		const Packet4c &
	)

pdiv< Packet4cd >()

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pdiv< Packet4cd >	(	const Packet4cd &	a,
		const Packet4cd &	b
	)

pdiv< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pdiv< Packet4cf >	(	const Packet4cf &	a,
		const Packet4cf &	b
	)

pdiv< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pdiv< Packet4d >	(	const Packet4d &	a,
		const Packet4d &	b
	)

pdiv< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pdiv< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pdiv< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pdiv< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pdiv< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pdiv< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pdiv< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pdiv< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pdiv< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pdiv< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pdiv< Packet4i >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pdiv< Packet4i >	(	const Packet4i &	,
		const Packet4i &
	)

pdiv< Packet4i >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pdiv< Packet4i >	(	const Packet4i &	,
		const Packet4i &
	)

pdiv< Packet4i >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pdiv< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pdiv< Packet4i >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pdiv< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pdiv< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pdiv< Packet4s >	(	const Packet4s &	,
		const Packet4s &
	)

pdiv< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pdiv< Packet4uc >	(	const Packet4uc &	,
		const Packet4uc &
	)

pdiv< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pdiv< Packet4ui >	(	const Packet4ui &	,
		const Packet4ui &
	)

pdiv< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pdiv< Packet4us >	(	const Packet4us &	,
		const Packet4us &
	)

pdiv< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pdiv< Packet8bf >	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pdiv< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pdiv< Packet8bf >	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pdiv< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pdiv< Packet8c >	(	const Packet8c &	,
		const Packet8c &
	)

pdiv< Packet8cf >()

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pdiv< Packet8cf >	(	const Packet8cf &	a,
		const Packet8cf &	b
	)

pdiv< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pdiv< Packet8d >	(	const Packet8d &	a,
		const Packet8d &	b
	)

pdiv< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pdiv< Packet8f >	(	const Packet8f &	a,
		const Packet8f &	b
	)

pdiv< Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pdiv< Packet8h >	(	const Packet8h &	a,
		const Packet8h &	b
	)

pdiv< Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::pdiv< Packet8i >	(	const Packet8i &	,
		const Packet8i &
	)

pdiv< Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pdiv< Packet8s >	(	const Packet8s &	,
		const Packet8s &
	)

pdiv< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pdiv< Packet8uc >	(	const Packet8uc &	,
		const Packet8uc &
	)

pdiv< Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pdiv< Packet8us >	(	const Packet8us &	,
		const Packet8us &
	)

pdiv< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pdiv< PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

pdiv< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pdiv< PacketXi >	(	const PacketXi &	a,
		const PacketXi &	b
	)

perf()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::perf

(

const Packet &

a

)

perfc()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::perfc

(

const Packet &

a

)

permute_symm_to_fullsymm()

template<int Mode, typename MatrixType , int DestOrder>

void Eigen::internal::permute_symm_to_fullsymm	(	const MatrixType &	mat,
		SparseMatrix< typename MatrixType::Scalar, DestOrder, typename MatrixType::StorageIndex > &	_dest,
		const typename MatrixType::StorageIndex *	perm = 0
	)

permute_symm_to_symm() [1/2]

template<int SrcMode, int DstMode, typename MatrixType , int DestOrder>

void Eigen::internal::permute_symm_to_symm	(	const MatrixType &	mat,
		SparseMatrix< typename MatrixType::Scalar, DestOrder, typename MatrixType::StorageIndex > &	_dest,
		const typename MatrixType::StorageIndex *	perm = 0
	)

permute_symm_to_symm() [2/2]

template<int _SrcMode, int _DstMode, typename MatrixType , int DstOrder>

void Eigen::internal::permute_symm_to_symm ( const MatrixType &  mat, SparseMatrix< typename MatrixType::Scalar, DstOrder, typename MatrixType::StorageIndex > &  _dest, const typename MatrixType::StorageIndex *  perm  )

protected

peven_mask() [1/10]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::peven_mask ( const Packet &  )

inline

peven_mask() [2/10]

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::peven_mask

(

const Packet16f &

)

peven_mask() [3/10]

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::peven_mask

(

const Packet16i &

)

peven_mask() [4/10]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::peven_mask

(

const Packet2d &

)

peven_mask() [5/10]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::peven_mask

(

const Packet4d &

)

peven_mask() [6/10]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::peven_mask

(

const Packet4f &

)

peven_mask() [7/10]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::peven_mask

(

const Packet4i &

)

peven_mask() [8/10]

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::peven_mask

(

const Packet8d &

)

peven_mask() [9/10]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::peven_mask

(

const Packet8f &

)

peven_mask() [10/10]

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::peven_mask

(

const Packet8i &

)

pexp()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pexp

(

const Packet &

a

)

pexp< Packet2d >() [1/3]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d Eigen::internal::pexp< Packet2d >

(

const Packet2d &

_x

)

pexp< Packet2d >() [2/3]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d Eigen::internal::pexp< Packet2d >

(

const Packet2d &

_x

)

pexp< Packet2d >() [3/3]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d Eigen::internal::pexp< Packet2d >

(

const Packet2d &

x

)

pexp< Packet2f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f Eigen::internal::pexp< Packet2f >

(

const Packet2f &

x

)

pexp< Packet4d >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d Eigen::internal::pexp< Packet4d >

(

const Packet4d &

_x

)

pexp< Packet4f >() [1/5]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::pexp< Packet4f >

(

const Packet4f &

_x

)

pexp< Packet4f >() [2/5]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::pexp< Packet4f >

(

const Packet4f &

_x

)

pexp< Packet4f >() [3/5]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::pexp< Packet4f >

(

const Packet4f &

_x

)

pexp< Packet4f >() [4/5]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::pexp< Packet4f >

(

const Packet4f &

_x

)

pexp< Packet4f >() [5/5]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::pexp< Packet4f >

(

const Packet4f &

x

)

pexp< Packet8bf >()

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pexp< Packet8bf >

(

const Packet8bf &

a

)

pexp< Packet8f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f Eigen::internal::pexp< Packet8f >

(

const Packet8f &

_x

)

pexp< PacketXf >()

template<>

EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf Eigen::internal::pexp< PacketXf >

(

const PacketXf &

x

)

pexp_double()

template<typename Packet >

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::pexp_double

(

const Packet

_x

)

pexp_float()

template<typename Packet >

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::pexp_float

(

const Packet

_x

)

pexpm1()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pexpm1

(

const Packet &

a

)

pexpm1< Packet4f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::pexpm1< Packet4f >

(

const Packet4f &

_x

)

pexpm1< Packet8f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f Eigen::internal::pexpm1< Packet8f >

(

const Packet8f &

_x

)

pfirst() [1/2]

template<typename Packet >

EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type Eigen::internal::pfirst ( const Packet &  a )

inline

pfirst() [2/2]

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::pfirst

(

const Packet8bf &

a

)

pfirst< Packet16b >()

template<>

EIGEN_STRONG_INLINE bool Eigen::internal::pfirst< Packet16b >

(

const Packet16b &

a

)

pfirst< Packet16bf >()

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::pfirst< Packet16bf >

(

const Packet16bf &

from

)

pfirst< Packet16c >() [1/2]

template<>

EIGEN_STRONG_INLINE signed char Eigen::internal::pfirst< Packet16c >

(

const Packet16c &

a

)

pfirst< Packet16c >() [2/2]

template<>

EIGEN_STRONG_INLINE int8_t Eigen::internal::pfirst< Packet16c >

(

const Packet16c &

a

)

pfirst< Packet16f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet16f >

(

const Packet16f &

a

)

pfirst< Packet16h >()

template<>

EIGEN_STRONG_INLINE Eigen::half Eigen::internal::pfirst< Packet16h >

(

const Packet16h &

from

)

pfirst< Packet16i >()

template<>

EIGEN_STRONG_INLINE int Eigen::internal::pfirst< Packet16i >

(

const Packet16i &

a

)

pfirst< Packet16uc >() [1/2]

template<>

EIGEN_STRONG_INLINE unsigned char Eigen::internal::pfirst< Packet16uc >

(

const Packet16uc &

a

)

pfirst< Packet16uc >() [2/2]

template<>

EIGEN_STRONG_INLINE uint8_t Eigen::internal::pfirst< Packet16uc >

(

const Packet16uc &

a

)

pfirst< Packet1cd >() [1/3]

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::pfirst< Packet1cd >

(

const Packet1cd &

a

)

pfirst< Packet1cd >() [2/3]

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::pfirst< Packet1cd >

(

const Packet1cd &

a

)

pfirst< Packet1cd >() [3/3]

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::pfirst< Packet1cd >

(

const Packet1cd &

a

)

pfirst< Packet1cf >()

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::pfirst< Packet1cf >

(

const Packet1cf &

a

)

pfirst< Packet2cd >()

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::pfirst< Packet2cd >

(

const Packet2cd &

a

)

pfirst< Packet2cf >() [1/5]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::pfirst< Packet2cf >

(

const Packet2cf &

a

)

pfirst< Packet2cf >() [2/5]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::pfirst< Packet2cf >

(

const Packet2cf &

a

)

pfirst< Packet2cf >() [3/5]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::pfirst< Packet2cf >

(

const Packet2cf &

a

)

pfirst< Packet2cf >() [4/5]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::pfirst< Packet2cf >

(

const Packet2cf &

a

)

pfirst< Packet2cf >() [5/5]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::pfirst< Packet2cf >

(

const Packet2cf &

a

)

pfirst< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::pfirst< Packet2d >

(

const Packet2d &

a

)

pfirst< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::pfirst< Packet2d >

(

const Packet2d &

a

)

pfirst< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::pfirst< Packet2d >

(

const Packet2d &

a

)

pfirst< Packet2f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet2f >

(

const Packet2f &

a

)

pfirst< Packet2i >()

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::pfirst< Packet2i >

(

const Packet2i &

a

)

pfirst< Packet2l >()

template<>

EIGEN_STRONG_INLINE int64_t Eigen::internal::pfirst< Packet2l >

(

const Packet2l &

a

)

pfirst< Packet2ui >()

template<>

EIGEN_STRONG_INLINE uint32_t Eigen::internal::pfirst< Packet2ui >

(

const Packet2ui &

a

)

pfirst< Packet2ul >()

template<>

EIGEN_STRONG_INLINE uint64_t Eigen::internal::pfirst< Packet2ul >

(

const Packet2ul &

a

)

pfirst< Packet4bf >()

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::pfirst< Packet4bf >

(

const Packet4bf &

from

)

pfirst< Packet4c >()

template<>

EIGEN_STRONG_INLINE int8_t Eigen::internal::pfirst< Packet4c >

(

const Packet4c &

a

)

pfirst< Packet4cd >()

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::pfirst< Packet4cd >

(

const Packet4cd &

a

)

pfirst< Packet4cf >()

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::pfirst< Packet4cf >

(

const Packet4cf &

a

)

pfirst< Packet4d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::pfirst< Packet4d >

(

const Packet4d &

a

)

pfirst< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet4f >

(

const Packet4f &

a

)

pfirst< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet4f >

(

const Packet4f &

a

)

pfirst< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet4f >

(

const Packet4f &

a

)

pfirst< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet4f >

(

const Packet4f &

a

)

pfirst< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet4f >

(

const Packet4f &

a

)

pfirst< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::pfirst< Packet4i >

(

const Packet4i &

a

)

pfirst< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::pfirst< Packet4i >

(

const Packet4i &

a

)

pfirst< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::pfirst< Packet4i >

(

const Packet4i &

a

)

pfirst< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::pfirst< Packet4i >

(

const Packet4i &

a

)

pfirst< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::pfirst< Packet4i >

(

const Packet4i &

a

)

pfirst< Packet4s >()

template<>

EIGEN_STRONG_INLINE int16_t Eigen::internal::pfirst< Packet4s >

(

const Packet4s &

a

)

pfirst< Packet4uc >()

template<>

EIGEN_STRONG_INLINE uint8_t Eigen::internal::pfirst< Packet4uc >

(

const Packet4uc &

a

)

pfirst< Packet4ui >()

template<>

EIGEN_STRONG_INLINE uint32_t Eigen::internal::pfirst< Packet4ui >

(

const Packet4ui &

a

)

pfirst< Packet4us >()

template<>

EIGEN_STRONG_INLINE uint16_t Eigen::internal::pfirst< Packet4us >

(

const Packet4us &

a

)

pfirst< Packet8bf >()

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::pfirst< Packet8bf >

(

const Packet8bf &

from

)

pfirst< Packet8c >()

template<>

EIGEN_STRONG_INLINE int8_t Eigen::internal::pfirst< Packet8c >

(

const Packet8c &

a

)

pfirst< Packet8cf >()

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::pfirst< Packet8cf >

(

const Packet8cf &

a

)

pfirst< Packet8d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::pfirst< Packet8d >

(

const Packet8d &

a

)

pfirst< Packet8f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet8f >

(

const Packet8f &

a

)

pfirst< Packet8h >()

template<>

EIGEN_STRONG_INLINE Eigen::half Eigen::internal::pfirst< Packet8h >

(

const Packet8h &

from

)

pfirst< Packet8i >()

template<>

EIGEN_STRONG_INLINE int Eigen::internal::pfirst< Packet8i >

(

const Packet8i &

a

)

pfirst< Packet8s >() [1/2]

template<>

EIGEN_STRONG_INLINE short int Eigen::internal::pfirst< Packet8s >

(

const Packet8s &

a

)

pfirst< Packet8s >() [2/2]

template<>

EIGEN_STRONG_INLINE int16_t Eigen::internal::pfirst< Packet8s >

(

const Packet8s &

a

)

pfirst< Packet8uc >()

template<>

EIGEN_STRONG_INLINE uint8_t Eigen::internal::pfirst< Packet8uc >

(

const Packet8uc &

a

)

pfirst< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE unsigned short int Eigen::internal::pfirst< Packet8us >

(

const Packet8us &

a

)

pfirst< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE uint16_t Eigen::internal::pfirst< Packet8us >

(

const Packet8us &

a

)

pfirst< PacketXf >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::pfirst< PacketXf >

(

const PacketXf &

a

)

pfirst< PacketXi >()

template<>

EIGEN_STRONG_INLINE numext::int32_t Eigen::internal::pfirst< PacketXi >

(

const PacketXi &

a

)

pfloor()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pfloor

(

const Packet &

a

)

pfloor< Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pfloor< Packet16bf >

(

const Packet16bf &

a

)

pfloor< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pfloor< Packet16f >

(

const Packet16f &

a

)

pfloor< Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pfloor< Packet16h >

(

const Packet16h &

a

)

pfloor< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pfloor< Packet2d >

(

const Packet2d &

a

)

pfloor< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pfloor< Packet2d >

(

const Packet2d &

a

)

pfloor< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pfloor< Packet2d >

(

const Packet2d &

a

)

pfloor< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pfloor< Packet2f >

(

const Packet2f &

a

)

pfloor< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pfloor< Packet4bf >

(

const Packet4bf &

a

)

pfloor< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pfloor< Packet4d >

(

const Packet4d &

a

)

pfloor< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pfloor< Packet4f >

(

const Packet4f &

a

)

pfloor< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pfloor< Packet4f >

(

const Packet4f &

a

)

pfloor< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pfloor< Packet4f >

(

const Packet4f &

a

)

pfloor< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pfloor< Packet4f >

(

const Packet4f &

a

)

pfloor< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pfloor< Packet4f >

(

const Packet4f &

a

)

pfloor< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pfloor< Packet8bf >

(

const Packet8bf &

a

)

pfloor< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pfloor< Packet8bf >

(

const Packet8bf &

a

)

pfloor< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pfloor< Packet8d >

(

const Packet8d &

a

)

pfloor< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pfloor< Packet8f >

(

const Packet8f &

a

)

pfloor< Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pfloor< Packet8h >

(

const Packet8h &

a

)

pfloor< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pfloor< PacketXf >

(

const PacketXf &

a

)

pfrexp() [1/4]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pfrexp ( const Packet &  a, Packet &  exponent  )

inline

pfrexp() [2/4]

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pfrexp	(	const Packet4bf &	a,
		Packet4bf &	exponent
	)

pfrexp() [3/4]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pfrexp	(	const Packet8bf &	a,
		Packet8bf &	exponent
	)

pfrexp() [4/4]

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pfrexp	(	const Packet8h &	a,
		Packet8h &	exponent
	)

pfrexp< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pfrexp< Packet16f >	(	const Packet16f &	a,
		Packet16f &	exponent
	)

pfrexp< Packet2d >()

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pfrexp< Packet2d >	(	const Packet2d &	a,
		Packet2d &	exponent
	)

pfrexp< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pfrexp< Packet2f >	(	const Packet2f &	a,
		Packet2f &	exponent
	)

pfrexp< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pfrexp< Packet4d >	(	const Packet4d &	a,
		Packet4d &	exponent
	)

pfrexp< Packet4f >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pfrexp< Packet4f >	(	const Packet4f &	a,
		Packet4f &	exponent
	)

pfrexp< Packet4f >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pfrexp< Packet4f >	(	const Packet4f &	a,
		Packet4f &	exponent
	)

pfrexp< Packet4f >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pfrexp< Packet4f >	(	const Packet4f &	a,
		Packet4f &	exponent
	)

pfrexp< Packet8bf >()

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pfrexp< Packet8bf >	(	const Packet8bf &	a,
		Packet8bf &	e
	)

pfrexp< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pfrexp< Packet8d >	(	const Packet8d &	a,
		Packet8d &	exponent
	)

pfrexp< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pfrexp< Packet8f >	(	const Packet8f &	a,
		Packet8f &	exponent
	)

pfrexp< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pfrexp< PacketXf >	(	const PacketXf &	a,
		PacketXf &	exponent
	)

pfrexp_generic()

template<typename Packet >

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet Eigen::internal::pfrexp_generic	(	const Packet &	a,
		Packet &	exponent
	)

Default implementation of pfrexp. It is expected to be called by implementers of template<> pfrexp.

pfrexp_generic_get_biased_exponent() [1/4]

template<typename Packet >

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet Eigen::internal::pfrexp_generic_get_biased_exponent

(

const Packet &

a

)

pfrexp_generic_get_biased_exponent() [2/4]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pfrexp_generic_get_biased_exponent

(

const Packet2d &

a

)

pfrexp_generic_get_biased_exponent() [3/4]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pfrexp_generic_get_biased_exponent

(

const Packet4d &

a

)

pfrexp_generic_get_biased_exponent() [4/4]

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pfrexp_generic_get_biased_exponent

(

const Packet8d &

a

)

pgamma_sample_der_alpha()

template<typename Packet >

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

pgather()

template<typename Scalar , typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pgather ( const Scalar *  from, Index    )

inline

pgather< bfloat16, Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pgather< bfloat16, Packet16bf >	(	const bfloat16 *	from,
		Index	stride
	)

pgather< bfloat16, Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pgather< bfloat16, Packet4bf >	(	const bfloat16 *	from,
		Index	stride
	)

pgather< bfloat16, Packet8bf >() [1/2]

template<>

EIGEN_DEVICE_FUNC Packet8bf Eigen::internal::pgather< bfloat16, Packet8bf > ( const bfloat16 *  from, Index  stride  )

inline

pgather< bfloat16, Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pgather< bfloat16, Packet8bf >	(	const bfloat16 *	from,
		Index	stride
	)

pgather< bool, Packet16b >()

template<>

EIGEN_DEVICE_FUNC Packet16b Eigen::internal::pgather< bool, Packet16b > ( const bool *  from, Index  stride  )

inline

pgather< double, Packet2d >() [1/3]

template<>

EIGEN_DEVICE_FUNC Packet2d Eigen::internal::pgather< double, Packet2d > ( const double *  from, Index  stride  )

inline

pgather< double, Packet2d >() [2/3]

template<>

EIGEN_DEVICE_FUNC Packet2d Eigen::internal::pgather< double, Packet2d > ( const double *  from, Index  stride  )

inline

pgather< double, Packet2d >() [3/3]

template<>

EIGEN_DEVICE_FUNC Packet2d Eigen::internal::pgather< double, Packet2d > ( const double *  from, Index  stride  )

inline

pgather< double, Packet4d >()

template<>

EIGEN_DEVICE_FUNC Packet4d Eigen::internal::pgather< double, Packet4d > ( const double *  from, Index  stride  )

inline

pgather< double, Packet8d >()

template<>

EIGEN_DEVICE_FUNC Packet8d Eigen::internal::pgather< double, Packet8d > ( const double *  from, Index  stride  )

inline

pgather< Eigen::half, Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pgather< Eigen::half, Packet16h >	(	const Eigen::half *	from,
		Index	stride
	)

pgather< Eigen::half, Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pgather< Eigen::half, Packet8h >	(	const Eigen::half *	from,
		Index	stride
	)

pgather< float, Packet16f >()

template<>

EIGEN_DEVICE_FUNC Packet16f Eigen::internal::pgather< float, Packet16f > ( const float *  from, Index  stride  )

inline

pgather< float, Packet2f >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2f Eigen::internal::pgather< float, Packet2f >	(	const float *	from,
		Index	stride
	)

pgather< float, Packet4f >() [1/5]

template<>

EIGEN_DEVICE_FUNC Packet4f Eigen::internal::pgather< float, Packet4f > ( const float *  from, Index  stride  )

inline

pgather< float, Packet4f >() [2/5]

template<>

EIGEN_DEVICE_FUNC Packet4f Eigen::internal::pgather< float, Packet4f > ( const float *  from, Index  stride  )

inline

pgather< float, Packet4f >() [3/5]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4f Eigen::internal::pgather< float, Packet4f >	(	const float *	from,
		Index	stride
	)

pgather< float, Packet4f >() [4/5]

template<>

EIGEN_DEVICE_FUNC Packet4f Eigen::internal::pgather< float, Packet4f > ( const float *  from, Index  stride  )

inline

pgather< float, Packet4f >() [5/5]

template<>

EIGEN_DEVICE_FUNC Packet4f Eigen::internal::pgather< float, Packet4f > ( const float *  from, Index  stride  )

inline

pgather< float, Packet8f >()

template<>

EIGEN_DEVICE_FUNC Packet8f Eigen::internal::pgather< float, Packet8f > ( const float *  from, Index  stride  )

inline

pgather< float, PacketXf >()

template<>

EIGEN_DEVICE_FUNC PacketXf Eigen::internal::pgather< float, PacketXf > ( const float *  from, Index  stride  )

inline

pgather< int, Packet4i >() [1/3]

template<>

EIGEN_DEVICE_FUNC Packet4i Eigen::internal::pgather< int, Packet4i > ( const int *  from, Index  stride  )

inline

pgather< int, Packet4i >() [2/3]

template<>

EIGEN_DEVICE_FUNC Packet4i Eigen::internal::pgather< int, Packet4i > ( const int *  from, Index  stride  )

inline

pgather< int, Packet4i >() [3/3]

template<>

EIGEN_DEVICE_FUNC Packet4i Eigen::internal::pgather< int, Packet4i > ( const int *  from, Index  stride  )

inline

pgather< int16_t, Packet4s >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s Eigen::internal::pgather< int16_t, Packet4s >	(	const int16_t *	from,
		Index	stride
	)

pgather< int16_t, Packet8s >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8s Eigen::internal::pgather< int16_t, Packet8s >	(	const int16_t *	from,
		Index	stride
	)

pgather< int32_t, Packet2i >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2i Eigen::internal::pgather< int32_t, Packet2i >	(	const int32_t *	from,
		Index	stride
	)

pgather< int32_t, Packet4i >() [1/2]

template<>

EIGEN_DEVICE_FUNC Packet4i Eigen::internal::pgather< int32_t, Packet4i > ( const int32_t *  from, Index  stride  )

inline

pgather< int32_t, Packet4i >() [2/2]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4i Eigen::internal::pgather< int32_t, Packet4i >	(	const int32_t *	from,
		Index	stride
	)

pgather< int64_t, Packet2l >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2l Eigen::internal::pgather< int64_t, Packet2l >	(	const int64_t *	from,
		Index	stride
	)

pgather< int8_t, Packet16c >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16c Eigen::internal::pgather< int8_t, Packet16c >	(	const int8_t *	from,
		Index	stride
	)

pgather< int8_t, Packet4c >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4c Eigen::internal::pgather< int8_t, Packet4c >	(	const int8_t *	from,
		Index	stride
	)

pgather< int8_t, Packet8c >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c Eigen::internal::pgather< int8_t, Packet8c >	(	const int8_t *	from,
		Index	stride
	)

pgather< numext::int32_t, PacketXi >()

template<>

EIGEN_DEVICE_FUNC PacketXi Eigen::internal::pgather< numext::int32_t, PacketXi > ( const numext::int32_t *  from, Index  stride  )

inline

pgather< short int, Packet8s >()

template<>

EIGEN_DEVICE_FUNC Packet8s Eigen::internal::pgather< short int, Packet8s > ( const short int *  from, Index  stride  )

inline

pgather< signed char, Packet16c >()

template<>

EIGEN_DEVICE_FUNC Packet16c Eigen::internal::pgather< signed char, Packet16c > ( const signed char *  from, Index  stride  )

inline

pgather< std::complex< double >, Packet1cd >() [1/2]

template<>

EIGEN_DEVICE_FUNC Packet1cd Eigen::internal::pgather< std::complex< double >, Packet1cd > ( const std::complex< double > *  from, Index stride   __attribute__(unused)  )

inline

pgather< std::complex< double >, Packet1cd >() [2/2]

template<>

EIGEN_DEVICE_FUNC Packet1cd Eigen::internal::pgather< std::complex< double >, Packet1cd > ( const std::complex< double > *  from, Index stride  EIGEN_UNUSED  )

inline

pgather< std::complex< double >, Packet2cd >()

template<>

EIGEN_DEVICE_FUNC Packet2cd Eigen::internal::pgather< std::complex< double >, Packet2cd > ( const std::complex< double > *  from, Index  stride  )

inline

pgather< std::complex< double >, Packet4cd >()

template<>

EIGEN_DEVICE_FUNC Packet4cd Eigen::internal::pgather< std::complex< double >, Packet4cd > ( const std::complex< double > *  from, Index  stride  )

inline

pgather< std::complex< float >, Packet1cf >()

template<>

EIGEN_DEVICE_FUNC Packet1cf Eigen::internal::pgather< std::complex< float >, Packet1cf > ( const std::complex< float > *  from, Index  stride  )

inline

pgather< std::complex< float >, Packet2cf >() [1/5]

template<>

EIGEN_DEVICE_FUNC Packet2cf Eigen::internal::pgather< std::complex< float >, Packet2cf > ( const std::complex< float > *  from, Index  stride  )

inline

pgather< std::complex< float >, Packet2cf >() [2/5]

template<>

EIGEN_DEVICE_FUNC Packet2cf Eigen::internal::pgather< std::complex< float >, Packet2cf > ( const std::complex< float > *  from, Index  stride  )

inline

pgather< std::complex< float >, Packet2cf >() [3/5]

template<>

EIGEN_DEVICE_FUNC Packet2cf Eigen::internal::pgather< std::complex< float >, Packet2cf > ( const std::complex< float > *  from, Index  stride  )

inline

pgather< std::complex< float >, Packet2cf >() [4/5]

template<>

EIGEN_DEVICE_FUNC Packet2cf Eigen::internal::pgather< std::complex< float >, Packet2cf > ( const std::complex< float > *  from, Index  stride  )

inline

pgather< std::complex< float >, Packet2cf >() [5/5]

template<>

EIGEN_DEVICE_FUNC Packet2cf Eigen::internal::pgather< std::complex< float >, Packet2cf > ( const std::complex< float > *  from, Index  stride  )

inline

pgather< std::complex< float >, Packet4cf >()

template<>

EIGEN_DEVICE_FUNC Packet4cf Eigen::internal::pgather< std::complex< float >, Packet4cf > ( const std::complex< float > *  from, Index  stride  )

inline

pgather< std::complex< float >, Packet8cf >()

template<>

EIGEN_DEVICE_FUNC Packet8cf Eigen::internal::pgather< std::complex< float >, Packet8cf > ( const std::complex< float > *  from, Index  stride  )

inline

pgather< uint16_t, Packet4us >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us Eigen::internal::pgather< uint16_t, Packet4us >	(	const uint16_t *	from,
		Index	stride
	)

pgather< uint16_t, Packet8us >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8us Eigen::internal::pgather< uint16_t, Packet8us >	(	const uint16_t *	from,
		Index	stride
	)

pgather< uint32_t, Packet2ui >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pgather< uint32_t, Packet2ui >	(	const uint32_t *	from,
		Index	stride
	)

pgather< uint32_t, Packet4ui >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pgather< uint32_t, Packet4ui >	(	const uint32_t *	from,
		Index	stride
	)

pgather< uint64_t, Packet2ul >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pgather< uint64_t, Packet2ul >	(	const uint64_t *	from,
		Index	stride
	)

pgather< uint8_t, Packet16uc >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pgather< uint8_t, Packet16uc >	(	const uint8_t *	from,
		Index	stride
	)

pgather< uint8_t, Packet4uc >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pgather< uint8_t, Packet4uc >	(	const uint8_t *	from,
		Index	stride
	)

pgather< uint8_t, Packet8uc >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pgather< uint8_t, Packet8uc >	(	const uint8_t *	from,
		Index	stride
	)

pgather< unsigned char, Packet16uc >()

template<>

EIGEN_DEVICE_FUNC Packet16uc Eigen::internal::pgather< unsigned char, Packet16uc > ( const unsigned char *  from, Index  stride  )

inline

pgather< unsigned short int, Packet8us >()

template<>

EIGEN_DEVICE_FUNC Packet8us Eigen::internal::pgather< unsigned short int, Packet8us > ( const unsigned short int *  from, Index  stride  )

inline

pgather_common()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pgather_common ( const __UNPACK_TYPE__(Packet) *  from, Index  stride  )

inline

pgather_size16()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pgather_size16 ( const __UNPACK_TYPE__(Packet) *  from, Index  stride  )

inline

pgather_size8()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pgather_size8 ( const __UNPACK_TYPE__(Packet) *  from, Index  stride  )

inline

pger() [1/2]

template<int N, typename Scalar , typename Packet , bool NegativeAccumulate>

EIGEN_ALWAYS_INLINE void Eigen::internal::pger	(	PacketBlock< Packet, N > *	acc,
		const Scalar *	lhs,
		const Packet *	rhsV
	)

pger() [2/2]

template<int N, typename Scalar , typename Packet , typename Index , bool NegativeAccumulate>

EIGEN_ALWAYS_INLINE void Eigen::internal::pger	(	PacketBlock< Packet, N > *	acc,
		const Scalar *	lhs,
		const Packet *	rhsV,
		Index	remaining_rows
	)

pger_common() [1/2]

template<typename Packet , bool NegativeAccumulate>

EIGEN_ALWAYS_INLINE void Eigen::internal::pger_common	(	PacketBlock< Packet, 1 > *	acc,
		const Packet &	lhsV,
		const Packet *	rhsV
	)

pger_common() [2/2]

template<typename Packet , bool NegativeAccumulate>

EIGEN_ALWAYS_INLINE void Eigen::internal::pger_common	(	PacketBlock< Packet, 4 > *	acc,
		const Packet &	lhsV,
		const Packet *	rhsV
	)

pgerc() [1/2]

template<int N, typename Scalar , typename Packet , bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>

EIGEN_ALWAYS_INLINE void Eigen::internal::pgerc	(	PacketBlock< Packet, N > *	accReal,
		PacketBlock< Packet, N > *	accImag,
		const Scalar *	lhs_ptr,
		const Scalar *	lhs_ptr_imag,
		const Packet *	rhsV,
		const Packet *	rhsVi
	)

pgerc() [2/2]

template<int N, typename Scalar , typename Packet , typename Index , bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>

EIGEN_ALWAYS_INLINE void Eigen::internal::pgerc	(	PacketBlock< Packet, N > *	accReal,
		PacketBlock< Packet, N > *	accImag,
		const Scalar *	lhs_ptr,
		const Scalar *	lhs_ptr_imag,
		const Packet *	rhsV,
		const Packet *	rhsVi,
		Index	remaining_rows
	)

pgerc_common()

template<int N, typename Packet , bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>

EIGEN_ALWAYS_INLINE void Eigen::internal::pgerc_common	(	PacketBlock< Packet, N > *	accReal,
		PacketBlock< Packet, N > *	accImag,
		const Packet &	lhsV,
		const Packet &	lhsVi,
		const Packet *	rhsV,
		const Packet *	rhsVi
	)

pgercMMA()

template<typename Scalar , typename Packet , typename RhsPacket , bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>

EIGEN_ALWAYS_INLINE void Eigen::internal::pgercMMA	(	__vector_quad *	accReal,
		__vector_quad *	accImag,
		const Packet &	lhsV,
		const Packet &	lhsVi,
		const RhsPacket &	rhsV,
		const RhsPacket &	rhsVi
	)

pgerMMA() [1/4]

template<typename LhsPacket , typename RhsPacket , bool NegativeAccumulate>

EIGEN_ALWAYS_INLINE void Eigen::internal::pgerMMA	(	__vector_quad *	,
		const __vector_pair &	,
		const Packet4f &
	)

pgerMMA() [2/4]

template<typename LhsPacket , typename RhsPacket , bool NegativeAccumulate>

EIGEN_ALWAYS_INLINE void Eigen::internal::pgerMMA	(	__vector_quad *	acc,
		const __vector_pair &	a,
		const Packet2d &	b
	)

pgerMMA() [3/4]

template<typename LhsPacket , typename RhsPacket , bool NegativeAccumulate>

EIGEN_ALWAYS_INLINE void Eigen::internal::pgerMMA	(	__vector_quad *	acc,
		const PacketBlock< Packet2d, 2 > &	a,
		const Packet2d &	b
	)

pgerMMA() [4/4]

template<typename LhsPacket , typename RhsPacket , bool NegativeAccumulate>

EIGEN_ALWAYS_INLINE void Eigen::internal::pgerMMA	(	__vector_quad *	acc,
		const RhsPacket &	a,
		const LhsPacket &	b
	)

pigamma()

template<typename Packet >

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

pigamma_der_a()

template<typename Packet >

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

pigammac()

template<typename Packet >

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

pldexp() [1/4]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pldexp ( const Packet &  a, const Packet &  exponent  )

inline

pldexp() [2/4]

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pldexp	(	const Packet4bf &	a,
		const Packet4bf &	exponent
	)

pldexp() [3/4]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pldexp	(	const Packet8bf &	a,
		const Packet8bf &	exponent
	)

pldexp() [4/4]

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pldexp	(	const Packet8h &	a,
		const Packet8h &	exponent
	)

pldexp< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pldexp< Packet16f >	(	const Packet16f &	a,
		const Packet16f &	exponent
	)

pldexp< Packet2d >()

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pldexp< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	exponent
	)

pldexp< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pldexp< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	exponent
	)

pldexp< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pldexp< Packet4d >	(	const Packet4d &	a,
		const Packet4d &	exponent
	)

pldexp< Packet4f >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pldexp< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	exponent
	)

pldexp< Packet4f >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pldexp< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	exponent
	)

pldexp< Packet4f >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pldexp< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	exponent
	)

pldexp< Packet8bf >()

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pldexp< Packet8bf >	(	const Packet8bf &	a,
		const Packet8bf &	exponent
	)

pldexp< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pldexp< Packet8d >	(	const Packet8d &	a,
		const Packet8d &	exponent
	)

pldexp< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pldexp< Packet8f >	(	const Packet8f &	a,
		const Packet8f &	exponent
	)

pldexp< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pldexp< PacketXf >	(	const PacketXf &	a,
		const PacketXf &	exponent
	)

pldexp_generic()

template<typename Packet >

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet Eigen::internal::pldexp_generic	(	const Packet &	a,
		const Packet &	exponent
	)

Default implementation of pldexp. It is expected to be called by implementers of template<> pldexp.

plgamma()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::plgamma

(

const Packet &

a

)

pload()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pload ( const typename unpacket_traits< Packet >::type *  from )

inline

pload1()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pload1 ( const typename unpacket_traits< Packet >::type *  a )

inline

pload1< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pload1< Packet16f >

(

const float *

from

)

pload1< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pload1< Packet4d >

(

const double *

from

)

pload1< Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pload1< Packet4f >

(

const float *

from

)

pload1< Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pload1< Packet4i >

(

const int32_t *

from

)

pload1< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pload1< Packet8d >

(

const double *

from

)

pload1< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pload1< Packet8f >

(

const float *

from

)

pload2()

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pload2	(	const std::complex< float > *	from0,
		const std::complex< float > *	from1
	)

pload< Packet16b >()

template<>

EIGEN_STRONG_INLINE Packet16b Eigen::internal::pload< Packet16b >

(

const bool *

from

)

pload< Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pload< Packet16bf >

(

const bfloat16 *

from

)

pload< Packet16c >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pload< Packet16c >

(

const int8_t *

from

)

pload< Packet16c >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pload< Packet16c >

(

const signed char *

from

)

pload< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pload< Packet16f >

(

const float *

from

)

pload< Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pload< Packet16h >

(

const Eigen::half *

from

)

pload< Packet16i >()

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::pload< Packet16i >

(

const int *

from

)

pload< Packet16uc >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pload< Packet16uc >

(

const uint8_t *

from

)

pload< Packet16uc >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pload< Packet16uc >

(

const unsigned char *

from

)

pload< Packet1cd >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pload< Packet1cd >

(

const std::complex< double > *

from

)

pload< Packet1cd >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pload< Packet1cd >

(

const std::complex< double > *

from

)

pload< Packet1cd >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pload< Packet1cd >

(

const std::complex< double > *

from

)

pload< Packet1cf >()

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pload< Packet1cf >

(

const std::complex< float > *

from

)

pload< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pload< Packet2cd >

(

const std::complex< double > *

from

)

pload< Packet2cf >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pload< Packet2cf >

(

const std::complex< float > *

from

)

pload< Packet2cf >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pload< Packet2cf >

(

const std::complex< float > *

from

)

pload< Packet2cf >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pload< Packet2cf >

(

const std::complex< float > *

from

)

pload< Packet2cf >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pload< Packet2cf >

(

const std::complex< float > *

from

)

pload< Packet2cf >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pload< Packet2cf >

(

const std::complex< float > *

from

)

pload< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pload< Packet2d >

(

const double *

from

)

pload< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pload< Packet2d >

(

const double *

from

)

pload< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pload< Packet2d >

(

const double *

from

)

pload< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pload< Packet2f >

(

const float *

from

)

pload< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pload< Packet2i >

(

const int32_t *

from

)

pload< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pload< Packet2l >

(

const int64_t *

from

)

pload< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pload< Packet2ui >

(

const uint32_t *

from

)

pload< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pload< Packet2ul >

(

const uint64_t *

from

)

pload< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pload< Packet4bf >

(

const bfloat16 *

from

)

pload< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pload< Packet4c >

(

const int8_t *

from

)

pload< Packet4cd >()

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pload< Packet4cd >

(

const std::complex< double > *

from

)

pload< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pload< Packet4cf >

(

const std::complex< float > *

from

)

pload< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pload< Packet4d >

(

const double *

from

)

pload< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pload< Packet4f >

(

const float *

from

)

pload< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pload< Packet4f >

(

const float *

from

)

pload< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pload< Packet4f >

(

const float *

from

)

pload< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pload< Packet4f >

(

const float *

from

)

pload< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pload< Packet4f >

(

const float *

from

)

pload< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pload< Packet4i >

(

const int *

from

)

pload< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pload< Packet4i >

(

const int *

from

)

pload< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pload< Packet4i >

(

const int *

from

)

pload< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pload< Packet4i >

(

const int32_t *

from

)

pload< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pload< Packet4i >

(

const int32_t *

from

)

pload< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pload< Packet4s >

(

const int16_t *

from

)

pload< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pload< Packet4uc >

(

const uint8_t *

from

)

pload< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pload< Packet4ui >

(

const uint32_t *

from

)

pload< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pload< Packet4us >

(

const uint16_t *

from

)

pload< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pload< Packet8bf >

(

const bfloat16 *

from

)

pload< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pload< Packet8bf >

(

const bfloat16 *

from

)

pload< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pload< Packet8c >

(

const int8_t *

from

)

pload< Packet8cf >()

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pload< Packet8cf >

(

const std::complex< float > *

from

)

pload< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pload< Packet8d >

(

const double *

from

)

pload< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pload< Packet8f >

(

const float *

from

)

pload< Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pload< Packet8h >

(

const Eigen::half *

from

)

pload< Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::pload< Packet8i >

(

const int *

from

)

pload< Packet8s >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pload< Packet8s >

(

const int16_t *

from

)

pload< Packet8s >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pload< Packet8s >

(

const short int *

from

)

pload< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pload< Packet8uc >

(

const uint8_t *

from

)

pload< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pload< Packet8us >

(

const uint16_t *

from

)

pload< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pload< Packet8us >

(

const unsigned short int *

from

)

pload< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pload< PacketXf >

(

const float *

from

)

pload< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pload< PacketXi >

(

const numext::int32_t *

from

)

pload_common()

template<typename Packet >

EIGEN_STRONG_INLINE Packet Eigen::internal::pload_common

(

const __UNPACK_TYPE__(Packet) *

from

)

ploaddup()

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::ploaddup

(

const typename unpacket_traits< Packet >::type *

from

)

ploaddup< Packet16b >()

template<>

EIGEN_STRONG_INLINE Packet16b Eigen::internal::ploaddup< Packet16b >

(

const bool *

from

)

ploaddup< Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::ploaddup< Packet16bf >

(

const bfloat16 *

from

)

ploaddup< Packet16c >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::ploaddup< Packet16c >

(

const int8_t *

from

)

ploaddup< Packet16c >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::ploaddup< Packet16c >

(

const signed char *

from

)

ploaddup< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::ploaddup< Packet16f >

(

const float *

from

)

ploaddup< Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::ploaddup< Packet16h >

(

const Eigen::half *

from

)

ploaddup< Packet16uc >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::ploaddup< Packet16uc >

(

const uint8_t *

from

)

ploaddup< Packet16uc >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::ploaddup< Packet16uc >

(

const unsigned char *

from

)

ploaddup< Packet1cd >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::ploaddup< Packet1cd >

(

const std::complex< double > *

from

)

ploaddup< Packet1cd >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::ploaddup< Packet1cd >

(

const std::complex< double > *

from

)

ploaddup< Packet1cd >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::ploaddup< Packet1cd >

(

const std::complex< double > *

from

)

ploaddup< Packet1cf >()

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::ploaddup< Packet1cf >

(

const std::complex< float > *

from

)

ploaddup< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::ploaddup< Packet2cd >

(

const std::complex< double > *

from

)

ploaddup< Packet2cf >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploaddup< Packet2cf >

(

const std::complex< float > *

from

)

ploaddup< Packet2cf >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploaddup< Packet2cf >

(

const std::complex< float > *

from

)

ploaddup< Packet2cf >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploaddup< Packet2cf >

(

const std::complex< float > *

from

)

ploaddup< Packet2cf >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploaddup< Packet2cf >

(

const std::complex< float > *

from

)

ploaddup< Packet2cf >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploaddup< Packet2cf >

(

const std::complex< float > *

from

)

ploaddup< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::ploaddup< Packet2d >

(

const double *

from

)

ploaddup< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::ploaddup< Packet2d >

(

const double *

from

)

ploaddup< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::ploaddup< Packet2d >

(

const double *

from

)

ploaddup< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::ploaddup< Packet2f >

(

const float *

from

)

ploaddup< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::ploaddup< Packet2i >

(

const int32_t *

from

)

ploaddup< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::ploaddup< Packet2l >

(

const int64_t *

from

)

ploaddup< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::ploaddup< Packet2ui >

(

const uint32_t *

from

)

ploaddup< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::ploaddup< Packet2ul >

(

const uint64_t *

from

)

ploaddup< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::ploaddup< Packet4bf >

(

const bfloat16 *

from

)

ploaddup< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::ploaddup< Packet4c >

(

const int8_t *

from

)

ploaddup< Packet4cd >()

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::ploaddup< Packet4cd >

(

const std::complex< double > *

from

)

ploaddup< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::ploaddup< Packet4cf >

(

const std::complex< float > *

from

)

ploaddup< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::ploaddup< Packet4d >

(

const double *

from

)

ploaddup< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploaddup< Packet4f >

(

const float *

from

)

ploaddup< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploaddup< Packet4f >

(

const float *

from

)

ploaddup< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploaddup< Packet4f >

(

const float *

from

)

ploaddup< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploaddup< Packet4f >

(

const float *

from

)

ploaddup< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploaddup< Packet4f >

(

const float *

from

)

ploaddup< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploaddup< Packet4i >

(

const int *

from

)

ploaddup< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploaddup< Packet4i >

(

const int *

from

)

ploaddup< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploaddup< Packet4i >

(

const int *

from

)

ploaddup< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploaddup< Packet4i >

(

const int32_t *

from

)

ploaddup< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploaddup< Packet4i >

(

const int32_t *

from

)

ploaddup< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::ploaddup< Packet4s >

(

const int16_t *

from

)

ploaddup< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::ploaddup< Packet4uc >

(

const uint8_t *

from

)

ploaddup< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::ploaddup< Packet4ui >

(

const uint32_t *

from

)

ploaddup< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::ploaddup< Packet4us >

(

const uint16_t *

from

)

ploaddup< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::ploaddup< Packet8bf >

(

const bfloat16 *

from

)

ploaddup< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::ploaddup< Packet8bf >

(

const bfloat16 *

from

)

ploaddup< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::ploaddup< Packet8c >

(

const int8_t *

from

)

ploaddup< Packet8cf >()

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::ploaddup< Packet8cf >

(

const std::complex< float > *

from

)

ploaddup< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::ploaddup< Packet8d >

(

const double *

from

)

ploaddup< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::ploaddup< Packet8f >

(

const float *

from

)

ploaddup< Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::ploaddup< Packet8h >

(

const Eigen::half *

from

)

ploaddup< Packet8s >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::ploaddup< Packet8s >

(

const int16_t *

from

)

ploaddup< Packet8s >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::ploaddup< Packet8s >

(

const short int *

from

)

ploaddup< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::ploaddup< Packet8uc >

(

const uint8_t *

from

)

ploaddup< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::ploaddup< Packet8us >

(

const uint16_t *

from

)

ploaddup< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::ploaddup< Packet8us >

(

const unsigned short int *

from

)

ploaddup< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::ploaddup< PacketXf >

(

const float *

from

)

ploaddup< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::ploaddup< PacketXi >

(

const numext::int32_t *

from

)

ploaddup_common()

template<typename Packet >

EIGEN_STRONG_INLINE Packet Eigen::internal::ploaddup_common

(

const __UNPACK_TYPE__(Packet) *

from

)

ploadLhs()

template<typename Scalar , typename Packet >

EIGEN_ALWAYS_INLINE Packet Eigen::internal::ploadLhs

(

const Scalar *

lhs

)

ploadquad() [1/3]

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::ploadquad

(

const bfloat16 *

from

)

ploadquad() [2/3]

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::ploadquad

(

const Eigen::half *

from

)

ploadquad() [3/3]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::ploadquad ( const typename unpacket_traits< Packet >::type *  from )

inline

ploadquad< Packet16b >()

template<>

EIGEN_STRONG_INLINE Packet16b Eigen::internal::ploadquad< Packet16b >

(

const bool *

from

)

ploadquad< Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::ploadquad< Packet16c >

(

const int8_t *

from

)

ploadquad< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::ploadquad< Packet16f >

(

const float *

from

)

ploadquad< Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::ploadquad< Packet16uc >

(

const uint8_t *

from

)

ploadquad< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::ploadquad< Packet4c >

(

const int8_t *

from

)

ploadquad< Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploadquad< Packet4f >

(

const float *

from

)

ploadquad< Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploadquad< Packet4i >

(

const int32_t *

from

)

ploadquad< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::ploadquad< Packet4uc >

(

const uint8_t *

from

)

ploadquad< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::ploadquad< Packet4ui >

(

const uint32_t *

from

)

ploadquad< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::ploadquad< Packet8bf >

(

const bfloat16 *

from

)

ploadquad< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::ploadquad< Packet8bf >

(

const bfloat16 *

from

)

ploadquad< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::ploadquad< Packet8c >

(

const int8_t *

from

)

ploadquad< Packet8cf >()

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::ploadquad< Packet8cf >

(

const std::complex< float > *

from

)

ploadquad< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::ploadquad< Packet8d >

(

const double *

from

)

ploadquad< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::ploadquad< Packet8f >

(

const float *

from

)

ploadquad< Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::ploadquad< Packet8h >

(

const Eigen::half *

from

)

ploadquad< Packet8s >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::ploadquad< Packet8s >

(

const int16_t *

from

)

ploadquad< Packet8s >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::ploadquad< Packet8s >

(

const short int *

from

)

ploadquad< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::ploadquad< Packet8uc >

(

const uint8_t *

from

)

ploadquad< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::ploadquad< Packet8us >

(

const uint16_t *

from

)

ploadquad< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::ploadquad< Packet8us >

(

const unsigned short int *

from

)

ploadquad< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::ploadquad< PacketXf >

(

const float *

from

)

ploadquad< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::ploadquad< PacketXi >

(

const numext::int32_t *

from

)

ploadRhs()

template<typename Scalar , typename Packet >

EIGEN_ALWAYS_INLINE Packet Eigen::internal::ploadRhs

(

const Scalar *

rhs

)

ploadRhsMMA() [1/2]

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::ploadRhsMMA	(	const float *	,
		__vector_pair &
	)

ploadRhsMMA() [2/2]

template<typename Scalar , typename Packet >

EIGEN_ALWAYS_INLINE void Eigen::internal::ploadRhsMMA	(	const Scalar *	rhs,
		Packet &	rhsV
	)

ploadRhsMMA< double, __vector_pair >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::ploadRhsMMA< double, __vector_pair >	(	const double *	rhs,
		__vector_pair &	rhsV
	)

ploadRhsMMA< double, PacketBlock< Packet2d, 2 > >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::ploadRhsMMA< double, PacketBlock< Packet2d, 2 > >	(	const double *	rhs,
		PacketBlock< Packet2d, 2 > &	rhsV
	)

ploadt() [1/2]

template<typename packet_type , int Alignment>

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type Eigen::internal::ploadt

(

const Eigen::TensorSycl::internal::RangeAccess< cl::sycl::access::mode::read_write, typename unpacket_traits< packet_type >::type > &

from

)

ploadt() [2/2]

template<typename Packet , int Alignment>

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet Eigen::internal::ploadt

(

const typename unpacket_traits< Packet >::type *

from

)

ploadt_ro() [1/2]

template<typename packet_type , int Alignment, typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type Eigen::internal::ploadt_ro

(

const Eigen::TensorSycl::internal::RangeAccess< cl::sycl::access::mode::read_write, T > &

from

)

ploadt_ro() [2/2]

template<typename Packet , int LoadMode>

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet Eigen::internal::ploadt_ro

(

const typename unpacket_traits< Packet >::type *

from

)

ploadu() [1/2]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::ploadu ( const typename unpacket_traits< Packet >::type *  from )

inline

ploadu() [2/2]

template<typename Packet >

EIGEN_DEVICE_FUNC enable_if< unpacket_traits< Packet >::masked_load_available, Packet >::type Eigen::internal::ploadu ( const typename unpacket_traits< Packet >::type *  from, typename unpacket_traits< Packet >::mask_t  umask  )

inline

ploadu< Packet16b >()

template<>

EIGEN_STRONG_INLINE Packet16b Eigen::internal::ploadu< Packet16b >

(

const bool *

from

)

ploadu< Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::ploadu< Packet16bf >

(

const bfloat16 *

from

)

ploadu< Packet16c >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::ploadu< Packet16c >

(

const int8_t *

from

)

ploadu< Packet16c >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::ploadu< Packet16c >

(

const signed char *

from

)

ploadu< Packet16f >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::ploadu< Packet16f >

(

const float *

from

)

ploadu< Packet16f >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::ploadu< Packet16f >	(	const float *	from,
		uint16_t	umask
	)

ploadu< Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::ploadu< Packet16h >

(

const Eigen::half *

from

)

ploadu< Packet16i >()

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::ploadu< Packet16i >

(

const int *

from

)

ploadu< Packet16uc >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::ploadu< Packet16uc >

(

const uint8_t *

from

)

ploadu< Packet16uc >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::ploadu< Packet16uc >

(

const unsigned char *

from

)

ploadu< Packet1cd >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::ploadu< Packet1cd >

(

const std::complex< double > *

from

)

ploadu< Packet1cd >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::ploadu< Packet1cd >

(

const std::complex< double > *

from

)

ploadu< Packet1cd >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::ploadu< Packet1cd >

(

const std::complex< double > *

from

)

ploadu< Packet1cf >()

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::ploadu< Packet1cf >

(

const std::complex< float > *

from

)

ploadu< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::ploadu< Packet2cd >

(

const std::complex< double > *

from

)

ploadu< Packet2cf >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploadu< Packet2cf >

(

const std::complex< float > *

from

)

ploadu< Packet2cf >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploadu< Packet2cf >

(

const std::complex< float > *

from

)

ploadu< Packet2cf >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploadu< Packet2cf >

(

const std::complex< float > *

from

)

ploadu< Packet2cf >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploadu< Packet2cf >

(

const std::complex< float > *

from

)

ploadu< Packet2cf >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploadu< Packet2cf >

(

const std::complex< float > *

from

)

ploadu< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::ploadu< Packet2d >

(

const double *

from

)

ploadu< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::ploadu< Packet2d >

(

const double *

from

)

ploadu< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::ploadu< Packet2d >

(

const double *

from

)

ploadu< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::ploadu< Packet2f >

(

const float *

from

)

ploadu< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::ploadu< Packet2i >

(

const int32_t *

from

)

ploadu< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::ploadu< Packet2l >

(

const int64_t *

from

)

ploadu< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::ploadu< Packet2ui >

(

const uint32_t *

from

)

ploadu< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::ploadu< Packet2ul >

(

const uint64_t *

from

)

ploadu< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::ploadu< Packet4bf >

(

const bfloat16 *

from

)

ploadu< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::ploadu< Packet4c >

(

const int8_t *

from

)

ploadu< Packet4cd >()

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::ploadu< Packet4cd >

(

const std::complex< double > *

from

)

ploadu< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::ploadu< Packet4cf >

(

const std::complex< float > *

from

)

ploadu< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::ploadu< Packet4d >

(

const double *

from

)

ploadu< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploadu< Packet4f >

(

const float *

from

)

ploadu< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploadu< Packet4f >

(

const float *

from

)

ploadu< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploadu< Packet4f >

(

const float *

from

)

ploadu< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploadu< Packet4f >

(

const float *

from

)

ploadu< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploadu< Packet4f >

(

const float *

from

)

ploadu< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploadu< Packet4i >

(

const int *

from

)

ploadu< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploadu< Packet4i >

(

const int *

from

)

ploadu< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploadu< Packet4i >

(

const int *

from

)

ploadu< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploadu< Packet4i >

(

const int32_t *

from

)

ploadu< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploadu< Packet4i >

(

const int32_t *

from

)

ploadu< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::ploadu< Packet4s >

(

const int16_t *

from

)

ploadu< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::ploadu< Packet4uc >

(

const uint8_t *

from

)

ploadu< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::ploadu< Packet4ui >

(

const uint32_t *

from

)

ploadu< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::ploadu< Packet4us >

(

const uint16_t *

from

)

ploadu< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::ploadu< Packet8bf >

(

const bfloat16 *

from

)

ploadu< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::ploadu< Packet8bf >

(

const bfloat16 *

from

)

ploadu< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::ploadu< Packet8c >

(

const int8_t *

from

)

ploadu< Packet8cf >()

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::ploadu< Packet8cf >

(

const std::complex< float > *

from

)

ploadu< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::ploadu< Packet8d >

(

const double *

from

)

ploadu< Packet8f >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::ploadu< Packet8f >

(

const float *

from

)

ploadu< Packet8f >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::ploadu< Packet8f >	(	const float *	from,
		uint8_t	umask
	)

ploadu< Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::ploadu< Packet8h >

(

const Eigen::half *

from

)

ploadu< Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::ploadu< Packet8i >

(

const int *

from

)

ploadu< Packet8s >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::ploadu< Packet8s >

(

const int16_t *

from

)

ploadu< Packet8s >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::ploadu< Packet8s >

(

const short int *

from

)

ploadu< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::ploadu< Packet8uc >

(

const uint8_t *

from

)

ploadu< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::ploadu< Packet8us >

(

const uint16_t *

from

)

ploadu< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::ploadu< Packet8us >

(

const unsigned short int *

from

)

ploadu< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::ploadu< PacketXf >

(

const float *

from

)

ploadu< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::ploadu< PacketXi >

(

const numext::int32_t *

from

)

ploadu_common()

template<typename Packet >

EIGEN_STRONG_INLINE Packet Eigen::internal::ploadu_common

(

const __UNPACK_TYPE__(Packet) *

from

)

plog()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::plog

(

const Packet &

a

)

plog10()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::plog10

(

const Packet &

a

)

plog1p()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::plog1p

(

const Packet &

a

)

plog1p< Packet4f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::plog1p< Packet4f >

(

const Packet4f &

_x

)

plog1p< Packet8f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f Eigen::internal::plog1p< Packet8f >

(

const Packet8f &

_x

)

plog2()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::plog2

(

const Packet &

a

)

plog2< Packet2d >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d Eigen::internal::plog2< Packet2d >

(

const Packet2d &

_x

)

plog2< Packet4d >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d Eigen::internal::plog2< Packet4d >

(

const Packet4d &

_x

)

plog2< Packet4f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::plog2< Packet4f >

(

const Packet4f &

_x

)

plog2< Packet8f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f Eigen::internal::plog2< Packet8f >

(

const Packet8f &

_x

)

plog2_double()

template<typename Packet >

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::plog2_double

(

const Packet

_x

)

plog2_float()

template<typename Packet >

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::plog2_float

(

const Packet

_x

)

plog< Packet2d >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d Eigen::internal::plog< Packet2d >

(

const Packet2d &

_x

)

plog< Packet2f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f Eigen::internal::plog< Packet2f >

(

const Packet2f &

x

)

plog< Packet4d >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d Eigen::internal::plog< Packet4d >

(

const Packet4d &

_x

)

plog< Packet4f >() [1/4]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::plog< Packet4f >

(

const Packet4f &

_x

)

plog< Packet4f >() [2/4]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::plog< Packet4f >

(

const Packet4f &

_x

)

plog< Packet4f >() [3/4]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::plog< Packet4f >

(

const Packet4f &

_x

)

plog< Packet4f >() [4/4]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::plog< Packet4f >

(

const Packet4f &

x

)

plog< Packet8bf >()

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::plog< Packet8bf >

(

const Packet8bf &

a

)

plog< Packet8f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f Eigen::internal::plog< Packet8f >

(

const Packet8f &

_x

)

plog< PacketXf >()

template<>

EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf Eigen::internal::plog< PacketXf >

(

const PacketXf &

x

)

plog_double()

template<typename Packet >

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::plog_double

(

const Packet

_x

)

plog_float()

template<typename Packet >

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::plog_float

(

const Packet

_x

)

plog_impl_double()

template<typename Packet , bool base2>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::plog_impl_double

(

const Packet

_x

)

plog_impl_float()

template<typename Packet , bool base2>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::plog_impl_float

(

const Packet

_x

)

plogical_shift_left() [1/25]

template<int N>

EIGEN_DEVICE_FUNC int Eigen::internal::plogical_shift_left ( const int &  a )

inline

plogical_shift_left() [2/25]

template<int N>

EIGEN_DEVICE_FUNC long int Eigen::internal::plogical_shift_left ( const long int &  a )

inline

plogical_shift_left() [3/25]

template<int N>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::plogical_shift_left

(

const Packet4f &

a

)

plogical_shift_left() [4/25]

template<int N>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::plogical_shift_left

(

const Packet4i &

a

)

plogical_shift_left() [5/25]

template<int N>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::plogical_shift_left

(

const Packet4ui &

a

)

plogical_shift_left() [6/25]

template<int N>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::plogical_shift_left

(

const Packet8us &

a

)

plogical_shift_left() [7/25]

template<int N>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::plogical_shift_left

(

Packet16c

a

)

plogical_shift_left() [8/25]

template<int N>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::plogical_shift_left

(

Packet16i

a

)

plogical_shift_left() [9/25]

template<int N>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::plogical_shift_left

(

Packet16uc

a

)

plogical_shift_left() [10/25]

template<int N>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::plogical_shift_left

(

Packet2i

a

)

plogical_shift_left() [11/25]

template<int N>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::plogical_shift_left

(

Packet2l

a

)

plogical_shift_left() [12/25]

template<int N>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::plogical_shift_left

(

Packet2ui

a

)

plogical_shift_left() [13/25]

template<int N>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::plogical_shift_left

(

Packet2ul

a

)

plogical_shift_left() [14/25]

template<int N>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::plogical_shift_left

(

Packet4c &

a

)

plogical_shift_left() [15/25]

template<int N>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::plogical_shift_left

(

Packet4i

a

)

plogical_shift_left() [16/25]

template<int N>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::plogical_shift_left

(

Packet4s

a

)

plogical_shift_left() [17/25]

template<int N>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::plogical_shift_left

(

Packet4uc &

a

)

plogical_shift_left() [18/25]

template<int N>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::plogical_shift_left

(

Packet4ui

a

)

plogical_shift_left() [19/25]

template<int N>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::plogical_shift_left

(

Packet4us

a

)

plogical_shift_left() [20/25]

template<int N>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::plogical_shift_left

(

Packet8c

a

)

plogical_shift_left() [21/25]

template<int N>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::plogical_shift_left

(

Packet8i

a

)

plogical_shift_left() [22/25]

template<int N>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::plogical_shift_left

(

Packet8s

a

)

plogical_shift_left() [23/25]

template<int N>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::plogical_shift_left

(

Packet8uc

a

)

plogical_shift_left() [24/25]

template<int N>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::plogical_shift_left

(

Packet8us

a

)

plogical_shift_left() [25/25]

template<int N>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::plogical_shift_left

(

PacketXi

a

)

plogical_shift_right() [1/25]

template<int N>

EIGEN_DEVICE_FUNC int Eigen::internal::plogical_shift_right ( const int &  a )

inline

plogical_shift_right() [2/25]

template<int N>

EIGEN_DEVICE_FUNC long int Eigen::internal::plogical_shift_right ( const long int &  a )

inline

plogical_shift_right() [3/25]

template<int N>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::plogical_shift_right

(

const Packet4f &

a

)

plogical_shift_right() [4/25]

template<int N>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::plogical_shift_right

(

const Packet4i &

a

)

plogical_shift_right() [5/25]

template<int N>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::plogical_shift_right

(

const Packet4ui &

a

)

plogical_shift_right() [6/25]

template<int N>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::plogical_shift_right

(

const Packet8us &

a

)

plogical_shift_right() [7/25]

template<int N>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::plogical_shift_right

(

Packet16c

a

)

plogical_shift_right() [8/25]

template<int N>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::plogical_shift_right

(

Packet16i

a

)

plogical_shift_right() [9/25]

template<int N>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::plogical_shift_right

(

Packet16uc

a

)

plogical_shift_right() [10/25]

template<int N>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::plogical_shift_right

(

Packet2i

a

)

plogical_shift_right() [11/25]

template<int N>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::plogical_shift_right

(

Packet2l

a

)

plogical_shift_right() [12/25]

template<int N>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::plogical_shift_right

(

Packet2ui

a

)

plogical_shift_right() [13/25]

template<int N>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::plogical_shift_right

(

Packet2ul

a

)

plogical_shift_right() [14/25]

template<int N>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::plogical_shift_right

(

Packet4c &

a

)

plogical_shift_right() [15/25]

template<int N>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::plogical_shift_right

(

Packet4i

a

)

plogical_shift_right() [16/25]

template<int N>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::plogical_shift_right

(

Packet4s

a

)

plogical_shift_right() [17/25]

template<int N>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::plogical_shift_right

(

Packet4uc &

a

)

plogical_shift_right() [18/25]

template<int N>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::plogical_shift_right

(

Packet4ui

a

)

plogical_shift_right() [19/25]

template<int N>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::plogical_shift_right

(

Packet4us

a

)

plogical_shift_right() [20/25]

template<int N>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::plogical_shift_right

(

Packet8c

a

)

plogical_shift_right() [21/25]

template<int N>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::plogical_shift_right

(

Packet8i

a

)

plogical_shift_right() [22/25]

template<int N>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::plogical_shift_right

(

Packet8s

a

)

plogical_shift_right() [23/25]

template<int N>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::plogical_shift_right

(

Packet8uc

a

)

plogical_shift_right() [24/25]

template<int N>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::plogical_shift_right

(

Packet8us

a

)

plogical_shift_right() [25/25]

template<int N>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::plogical_shift_right

(

PacketXi

a

)

plset()

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::plset

(

const typename unpacket_traits< Packet >::type &

a

)

plset< Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::plset< Packet16bf >

(

const bfloat16 &

a

)

plset< Packet16c >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::plset< Packet16c >

(

const int8_t &

a

)

plset< Packet16c >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::plset< Packet16c >

(

const signed char &

a

)

plset< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::plset< Packet16f >

(

const float &

a

)

plset< Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::plset< Packet16h >

(

const half &

a

)

plset< Packet16uc >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::plset< Packet16uc >

(

const uint8_t &

a

)

plset< Packet16uc >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::plset< Packet16uc >

(

const unsigned char &

a

)

plset< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::plset< Packet2d >

(

const double &

a

)

plset< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::plset< Packet2d >

(

const double &

a

)

plset< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::plset< Packet2d >

(

const double &

a

)

plset< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::plset< Packet2f >

(

const float &

a

)

plset< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::plset< Packet2i >

(

const int32_t &

a

)

plset< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::plset< Packet2l >

(

const int64_t &

a

)

plset< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::plset< Packet2ui >

(

const uint32_t &

a

)

plset< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::plset< Packet2ul >

(

const uint64_t &

a

)

plset< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::plset< Packet4bf >

(

const bfloat16 &

a

)

plset< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::plset< Packet4c >

(

const int8_t &

a

)

plset< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::plset< Packet4d >

(

const double &

a

)

plset< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::plset< Packet4f >

(

const float &

a

)

plset< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::plset< Packet4f >

(

const float &

a

)

plset< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::plset< Packet4f >

(

const float &

a

)

plset< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::plset< Packet4f >

(

const float &

a

)

plset< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::plset< Packet4f >

(

const float &

a

)

plset< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::plset< Packet4i >

(

const int &

a

)

plset< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::plset< Packet4i >

(

const int &

a

)

plset< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::plset< Packet4i >

(

const int &

a

)

plset< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::plset< Packet4i >

(

const int32_t &

a

)

plset< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::plset< Packet4i >

(

const int32_t &

a

)

plset< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::plset< Packet4s >

(

const int16_t &

a

)

plset< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::plset< Packet4uc >

(

const uint8_t &

a

)

plset< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::plset< Packet4ui >

(

const uint32_t &

a

)

plset< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::plset< Packet4us >

(

const uint16_t &

a

)

plset< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::plset< Packet8bf >

(

const bfloat16 &

a

)

plset< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::plset< Packet8bf >

(

const bfloat16 &

a

)

plset< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::plset< Packet8c >

(

const int8_t &

a

)

plset< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::plset< Packet8d >

(

const double &

a

)

plset< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::plset< Packet8f >

(

const float &

a

)

plset< Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::plset< Packet8h >

(

const half &

a

)

plset< Packet8s >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::plset< Packet8s >

(

const int16_t &

a

)

plset< Packet8s >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::plset< Packet8s >

(

const short int &

a

)

plset< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::plset< Packet8uc >

(

const uint8_t &

a

)

plset< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::plset< Packet8us >

(

const uint16_t &

a

)

plset< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::plset< Packet8us >

(

const unsigned short int &

a

)

plset< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::plset< PacketXf >

(

const float &

a

)

plset< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::plset< PacketXi >

(

const numext::int32_t &

a

)

pmadd() [1/31]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pmadd ( const Packet &  a, const Packet &  b, const Packet &  c  )

inline

pmadd() [2/31]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pmadd	(	const Packet16c &	a,
		const Packet16c &	b,
		const Packet16c &	c
	)

pmadd() [3/31]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pmadd	(	const Packet16uc &	a,
		const Packet16uc &	b,
		const Packet16uc &	c
	)

pmadd() [4/31]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmadd	(	const Packet2d &	a,
		const Packet2d &	b,
		const Packet2d &	c
	)

pmadd() [5/31]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmadd	(	const Packet2d &	a,
		const Packet2d &	b,
		const Packet2d &	c
	)

pmadd() [6/31]

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pmadd	(	const Packet2f &	a,
		const Packet2f &	b,
		const Packet2f &	c
	)

pmadd() [7/31]

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pmadd	(	const Packet2i &	a,
		const Packet2i &	b,
		const Packet2i &	c
	)

pmadd() [8/31]

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pmadd	(	const Packet2ui &	a,
		const Packet2ui &	b,
		const Packet2ui &	c
	)

pmadd() [9/31]

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pmadd	(	const Packet4c &	a,
		const Packet4c &	b,
		const Packet4c &	c
	)

pmadd() [10/31]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmadd	(	const Packet4f &	a,
		const Packet4f &	b,
		const Packet4f &	c
	)

pmadd() [11/31]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmadd	(	const Packet4f &	a,
		const Packet4f &	b,
		const Packet4f &	c
	)

pmadd() [12/31]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmadd	(	const Packet4f &	a,
		const Packet4f &	b,
		const Packet4f &	c
	)

pmadd() [13/31]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmadd	(	const Packet4f &	a,
		const Packet4f &	b,
		const Packet4f &	c
	)

pmadd() [14/31]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmadd	(	const Packet4i &	a,
		const Packet4i &	b,
		const Packet4i &	c
	)

pmadd() [15/31]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmadd	(	const Packet4i &	a,
		const Packet4i &	b,
		const Packet4i &	c
	)

pmadd() [16/31]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmadd	(	const Packet4i &	a,
		const Packet4i &	b,
		const Packet4i &	c
	)

pmadd() [17/31]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmadd	(	const Packet4i &	a,
		const Packet4i &	b,
		const Packet4i &	c
	)

pmadd() [18/31]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmadd	(	const Packet4i &	a,
		const Packet4i &	b,
		const Packet4i &	c
	)

pmadd() [19/31]

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pmadd	(	const Packet4s &	a,
		const Packet4s &	b,
		const Packet4s &	c
	)

pmadd() [20/31]

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pmadd	(	const Packet4uc &	a,
		const Packet4uc &	b,
		const Packet4uc &	c
	)

pmadd() [21/31]

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pmadd	(	const Packet4ui &	a,
		const Packet4ui &	b,
		const Packet4ui &	c
	)

pmadd() [22/31]

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pmadd	(	const Packet4us &	a,
		const Packet4us &	b,
		const Packet4us &	c
	)

pmadd() [23/31]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pmadd	(	const Packet8bf &	a,
		const Packet8bf &	b,
		const Packet8bf &	c
	)

pmadd() [24/31]

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pmadd	(	const Packet8c &	a,
		const Packet8c &	b,
		const Packet8c &	c
	)

pmadd() [25/31]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pmadd	(	const Packet8s &	a,
		const Packet8s &	b,
		const Packet8s &	c
	)

pmadd() [26/31]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pmadd	(	const Packet8s &	a,
		const Packet8s &	b,
		const Packet8s &	c
	)

pmadd() [27/31]

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pmadd	(	const Packet8uc &	a,
		const Packet8uc &	b,
		const Packet8uc &	c
	)

pmadd() [28/31]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pmadd	(	const Packet8us &	a,
		const Packet8us &	b,
		const Packet8us &	c
	)

pmadd() [29/31]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pmadd	(	const Packet8us &	a,
		const Packet8us &	b,
		const Packet8us &	c
	)

pmadd() [30/31]

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pmadd	(	const PacketXf &	a,
		const PacketXf &	b,
		const PacketXf &	c
	)

pmadd() [31/31]

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pmadd	(	const PacketXi &	a,
		const PacketXi &	b,
		const PacketXi &	c
	)

pmax() [1/2]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pmax ( const Packet &  a, const Packet &  b  )

inline

pmax() [2/2]

template<int NaNPropagation, typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pmax ( const Packet &  a, const Packet &  b  )

inline

pmax< Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pmax< Packet16bf >	(	const Packet16bf &	a,
		const Packet16bf &	b
	)

pmax< Packet16c >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pmax< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

pmax< Packet16c >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pmax< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

pmax< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pmax< Packet16f >	(	const Packet16f &	a,
		const Packet16f &	b
	)

pmax< Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pmax< Packet16h >	(	const Packet16h &	a,
		const Packet16h &	b
	)

pmax< Packet16uc >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pmax< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

pmax< Packet16uc >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pmax< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

pmax< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmax< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pmax< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmax< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pmax< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmax< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pmax< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pmax< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

pmax< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pmax< Packet2i >	(	const Packet2i &	a,
		const Packet2i &	b
	)

pmax< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pmax< Packet2l >	(	const Packet2l &	a,
		const Packet2l &	b
	)

pmax< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pmax< Packet2ui >	(	const Packet2ui &	a,
		const Packet2ui &	b
	)

pmax< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pmax< Packet2ul >	(	const Packet2ul &	a,
		const Packet2ul &	b
	)

pmax< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pmax< Packet4bf >	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

pmax< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pmax< Packet4c >	(	const Packet4c &	a,
		const Packet4c &	b
	)

pmax< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pmax< Packet4d >	(	const Packet4d &	a,
		const Packet4d &	b
	)

pmax< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmax< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmax< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmax< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmax< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmax< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmax< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmax< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmax< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmax< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmax< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmax< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pmax< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmax< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pmax< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmax< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pmax< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmax< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pmax< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmax< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pmax< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pmax< Packet4s >	(	const Packet4s &	a,
		const Packet4s &	b
	)

pmax< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pmax< Packet4uc >	(	const Packet4uc &	a,
		const Packet4uc &	b
	)

pmax< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pmax< Packet4ui >	(	const Packet4ui &	a,
		const Packet4ui &	b
	)

pmax< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pmax< Packet4us >	(	const Packet4us &	a,
		const Packet4us &	b
	)

pmax< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pmax< Packet8bf >	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pmax< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pmax< Packet8bf >	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pmax< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pmax< Packet8c >	(	const Packet8c &	a,
		const Packet8c &	b
	)

pmax< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pmax< Packet8d >	(	const Packet8d &	a,
		const Packet8d &	b
	)

pmax< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pmax< Packet8f >	(	const Packet8f &	a,
		const Packet8f &	b
	)

pmax< Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pmax< Packet8h >	(	const Packet8h &	a,
		const Packet8h &	b
	)

pmax< Packet8s >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pmax< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

pmax< Packet8s >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pmax< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

pmax< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pmax< Packet8uc >	(	const Packet8uc &	a,
		const Packet8uc &	b
	)

pmax< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pmax< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

pmax< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pmax< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

pmax< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pmax< PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

pmax< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pmax< PacketXi >	(	const PacketXi &	a,
		const PacketXi &	b
	)

pmax< PropagateNaN, Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pmax< PropagateNaN, Packet16f >	(	const Packet16f &	a,
		const Packet16f &	b
	)

pmax< PropagateNaN, Packet2d >()

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmax< PropagateNaN, Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pmax< PropagateNaN, Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pmax< PropagateNaN, Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

pmax< PropagateNaN, Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pmax< PropagateNaN, Packet4bf >	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

pmax< PropagateNaN, Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pmax< PropagateNaN, Packet4d >	(	const Packet4d &	a,
		const Packet4d &	b
	)

pmax< PropagateNaN, Packet4f >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmax< PropagateNaN, Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmax< PropagateNaN, Packet4f >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmax< PropagateNaN, Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmax< PropagateNaN, Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pmax< PropagateNaN, Packet8d >	(	const Packet8d &	a,
		const Packet8d &	b
	)

pmax< PropagateNaN, Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pmax< PropagateNaN, Packet8f >	(	const Packet8f &	a,
		const Packet8f &	b
	)

pmax< PropagateNaN, PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pmax< PropagateNaN, PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

pmax< PropagateNumbers, Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pmax< PropagateNumbers, Packet16f >	(	const Packet16f &	a,
		const Packet16f &	b
	)

pmax< PropagateNumbers, Packet2d >()

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmax< PropagateNumbers, Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pmax< PropagateNumbers, Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pmax< PropagateNumbers, Packet4bf >	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

pmax< PropagateNumbers, Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pmax< PropagateNumbers, Packet4d >	(	const Packet4d &	a,
		const Packet4d &	b
	)

pmax< PropagateNumbers, Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmax< PropagateNumbers, Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmax< PropagateNumbers, Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pmax< PropagateNumbers, Packet8d >	(	const Packet8d &	a,
		const Packet8d &	b
	)

pmax< PropagateNumbers, Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pmax< PropagateNumbers, Packet8f >	(	const Packet8f &	a,
		const Packet8f &	b
	)

pmax< PropagateNumbers, PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pmax< PropagateNumbers, PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

pmin() [1/2]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pmin ( const Packet &  a, const Packet &  b  )

inline

pmin() [2/2]

template<int NaNPropagation, typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pmin ( const Packet &  a, const Packet &  b  )

inline

pmin< Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pmin< Packet16bf >	(	const Packet16bf &	a,
		const Packet16bf &	b
	)

pmin< Packet16c >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pmin< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

pmin< Packet16c >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pmin< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

pmin< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pmin< Packet16f >	(	const Packet16f &	a,
		const Packet16f &	b
	)

pmin< Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pmin< Packet16h >	(	const Packet16h &	a,
		const Packet16h &	b
	)

pmin< Packet16uc >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pmin< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

pmin< Packet16uc >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pmin< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

pmin< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmin< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pmin< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmin< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pmin< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmin< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pmin< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pmin< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

pmin< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pmin< Packet2i >	(	const Packet2i &	a,
		const Packet2i &	b
	)

pmin< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pmin< Packet2l >	(	const Packet2l &	a,
		const Packet2l &	b
	)

pmin< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pmin< Packet2ui >	(	const Packet2ui &	a,
		const Packet2ui &	b
	)

pmin< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pmin< Packet2ul >	(	const Packet2ul &	a,
		const Packet2ul &	b
	)

pmin< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pmin< Packet4bf >	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

pmin< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pmin< Packet4c >	(	const Packet4c &	a,
		const Packet4c &	b
	)

pmin< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pmin< Packet4d >	(	const Packet4d &	a,
		const Packet4d &	b
	)

pmin< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmin< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmin< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmin< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmin< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmin< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmin< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmin< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmin< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmin< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmin< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmin< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pmin< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmin< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pmin< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmin< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pmin< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmin< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pmin< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmin< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pmin< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pmin< Packet4s >	(	const Packet4s &	a,
		const Packet4s &	b
	)

pmin< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pmin< Packet4uc >	(	const Packet4uc &	a,
		const Packet4uc &	b
	)

pmin< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pmin< Packet4ui >	(	const Packet4ui &	a,
		const Packet4ui &	b
	)

pmin< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pmin< Packet4us >	(	const Packet4us &	a,
		const Packet4us &	b
	)

pmin< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pmin< Packet8bf >	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pmin< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pmin< Packet8bf >	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pmin< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pmin< Packet8c >	(	const Packet8c &	a,
		const Packet8c &	b
	)

pmin< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pmin< Packet8d >	(	const Packet8d &	a,
		const Packet8d &	b
	)

pmin< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pmin< Packet8f >	(	const Packet8f &	a,
		const Packet8f &	b
	)

pmin< Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pmin< Packet8h >	(	const Packet8h &	a,
		const Packet8h &	b
	)

pmin< Packet8s >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pmin< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

pmin< Packet8s >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pmin< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

pmin< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pmin< Packet8uc >	(	const Packet8uc &	a,
		const Packet8uc &	b
	)

pmin< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pmin< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

pmin< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pmin< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

pmin< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pmin< PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

pmin< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pmin< PacketXi >	(	const PacketXi &	a,
		const PacketXi &	b
	)

pmin< PropagateNaN, Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pmin< PropagateNaN, Packet16f >	(	const Packet16f &	a,
		const Packet16f &	b
	)

pmin< PropagateNaN, Packet2d >()

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmin< PropagateNaN, Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pmin< PropagateNaN, Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pmin< PropagateNaN, Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

pmin< PropagateNaN, Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pmin< PropagateNaN, Packet4bf >	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

pmin< PropagateNaN, Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pmin< PropagateNaN, Packet4d >	(	const Packet4d &	a,
		const Packet4d &	b
	)

pmin< PropagateNaN, Packet4f >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmin< PropagateNaN, Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmin< PropagateNaN, Packet4f >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmin< PropagateNaN, Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmin< PropagateNaN, Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pmin< PropagateNaN, Packet8d >	(	const Packet8d &	a,
		const Packet8d &	b
	)

pmin< PropagateNaN, Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pmin< PropagateNaN, Packet8f >	(	const Packet8f &	a,
		const Packet8f &	b
	)

pmin< PropagateNaN, PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pmin< PropagateNaN, PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

pmin< PropagateNumbers, Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pmin< PropagateNumbers, Packet16f >	(	const Packet16f &	a,
		const Packet16f &	b
	)

pmin< PropagateNumbers, Packet2d >()

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmin< PropagateNumbers, Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pmin< PropagateNumbers, Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pmin< PropagateNumbers, Packet4bf >	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

pmin< PropagateNumbers, Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pmin< PropagateNumbers, Packet4d >	(	const Packet4d &	a,
		const Packet4d &	b
	)

pmin< PropagateNumbers, Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmin< PropagateNumbers, Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmin< PropagateNumbers, Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pmin< PropagateNumbers, Packet8d >	(	const Packet8d &	a,
		const Packet8d &	b
	)

pmin< PropagateNumbers, Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pmin< PropagateNumbers, Packet8f >	(	const Packet8f &	a,
		const Packet8f &	b
	)

pmin< PropagateNumbers, PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pmin< PropagateNumbers, PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

pminmax_propagate_nan()

template<typename Packet , typename Op >

EIGEN_STRONG_INLINE Packet Eigen::internal::pminmax_propagate_nan	(	const Packet &	a,
		const Packet &	b,
		Op	op
	)

pminmax_propagate_numbers()

template<typename Packet , typename Op >

EIGEN_STRONG_INLINE Packet Eigen::internal::pminmax_propagate_numbers	(	const Packet &	a,
		const Packet &	b,
		Op	op
	)

pmul() [1/4]

template<>

EIGEN_DEVICE_FUNC bool Eigen::internal::pmul ( const bool &  a, const bool &  b  )

inline

pmul() [2/4]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pmul ( const Packet &  a, const Packet &  b  )

inline

pmul() [3/4]

template<>

std::complex< double > Eigen::internal::pmul ( const std::complex< double > &  a, const std::complex< double > &  b  )

inline

pmul() [4/4]

template<>

std::complex< float > Eigen::internal::pmul ( const std::complex< float > &  a, const std::complex< float > &  b  )

inline

pmul< Packet16b >()

template<>

EIGEN_STRONG_INLINE Packet16b Eigen::internal::pmul< Packet16b >	(	const Packet16b &	a,
		const Packet16b &	b
	)

pmul< Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pmul< Packet16bf >	(	const Packet16bf &	a,
		const Packet16bf &	b
	)

pmul< Packet16c >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pmul< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

pmul< Packet16c >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pmul< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

pmul< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pmul< Packet16f >	(	const Packet16f &	a,
		const Packet16f &	b
	)

pmul< Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pmul< Packet16h >	(	const Packet16h &	a,
		const Packet16h &	b
	)

pmul< Packet16i >()

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::pmul< Packet16i >	(	const Packet16i &	a,
		const Packet16i &	b
	)

pmul< Packet16uc >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pmul< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

pmul< Packet16uc >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pmul< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

pmul< Packet1cd >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pmul< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

pmul< Packet1cd >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pmul< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

pmul< Packet1cd >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pmul< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

pmul< Packet1cf >()

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pmul< Packet1cf >	(	const Packet1cf &	a,
		const Packet1cf &	b
	)

pmul< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pmul< Packet2cd >	(	const Packet2cd &	a,
		const Packet2cd &	b
	)

pmul< Packet2cf >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pmul< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pmul< Packet2cf >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pmul< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pmul< Packet2cf >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pmul< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pmul< Packet2cf >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pmul< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pmul< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmul< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pmul< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmul< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pmul< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmul< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pmul< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pmul< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

pmul< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pmul< Packet2i >	(	const Packet2i &	a,
		const Packet2i &	b
	)

pmul< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pmul< Packet2l >	(	const Packet2l &	a,
		const Packet2l &	b
	)

pmul< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pmul< Packet2ui >	(	const Packet2ui &	a,
		const Packet2ui &	b
	)

pmul< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pmul< Packet2ul >	(	const Packet2ul &	a,
		const Packet2ul &	b
	)

pmul< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pmul< Packet4bf >	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

pmul< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pmul< Packet4c >	(	const Packet4c &	a,
		const Packet4c &	b
	)

pmul< Packet4cd >()

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pmul< Packet4cd >	(	const Packet4cd &	a,
		const Packet4cd &	b
	)

pmul< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pmul< Packet4cf >	(	const Packet4cf &	a,
		const Packet4cf &	b
	)

pmul< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pmul< Packet4d >	(	const Packet4d &	a,
		const Packet4d &	b
	)

pmul< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmul< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmul< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmul< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmul< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmul< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmul< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmul< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmul< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmul< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pmul< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmul< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pmul< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmul< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pmul< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmul< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pmul< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmul< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pmul< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmul< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pmul< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pmul< Packet4s >	(	const Packet4s &	a,
		const Packet4s &	b
	)

pmul< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pmul< Packet4uc >	(	const Packet4uc &	a,
		const Packet4uc &	b
	)

pmul< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pmul< Packet4ui >	(	const Packet4ui &	a,
		const Packet4ui &	b
	)

pmul< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pmul< Packet4us >	(	const Packet4us &	a,
		const Packet4us &	b
	)

pmul< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pmul< Packet8bf >	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pmul< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pmul< Packet8bf >	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pmul< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pmul< Packet8c >	(	const Packet8c &	a,
		const Packet8c &	b
	)

pmul< Packet8cf >()

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pmul< Packet8cf >	(	const Packet8cf &	a,
		const Packet8cf &	b
	)

pmul< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pmul< Packet8d >	(	const Packet8d &	a,
		const Packet8d &	b
	)

pmul< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pmul< Packet8f >	(	const Packet8f &	a,
		const Packet8f &	b
	)

pmul< Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pmul< Packet8h >	(	const Packet8h &	a,
		const Packet8h &	b
	)

pmul< Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::pmul< Packet8i >	(	const Packet8i &	a,
		const Packet8i &	b
	)

pmul< Packet8s >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pmul< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

pmul< Packet8s >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pmul< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

pmul< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pmul< Packet8uc >	(	const Packet8uc &	a,
		const Packet8uc &	b
	)

pmul< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pmul< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

pmul< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pmul< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

pmul< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pmul< PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

pmul< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pmul< PacketXi >	(	const PacketXi &	a,
		const PacketXi &	b
	)

pndtri()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pndtri

(

const Packet &

a

)

pnegate() [1/47]

template<>

EIGEN_DEVICE_FUNC bool Eigen::internal::pnegate ( const bool &  a )

inline

pnegate() [2/47]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pnegate ( const Packet &  a )

inline

pnegate() [3/47]

template<>

EIGEN_STRONG_INLINE Packet16b Eigen::internal::pnegate

(

const Packet16b &

a

)

pnegate() [4/47]

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pnegate

(

const Packet16bf &

a

)

pnegate() [5/47]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pnegate

(

const Packet16c &

a

)

pnegate() [6/47]

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pnegate

(

const Packet16f &

a

)

pnegate() [7/47]

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pnegate

(

const Packet16h &

a

)

pnegate() [8/47]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pnegate

(

const Packet1cd &

a

)

pnegate() [9/47]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pnegate

(

const Packet1cd &

a

)

pnegate() [10/47]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pnegate

(

const Packet1cd &

a

)

pnegate() [11/47]

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pnegate

(

const Packet1cf &

a

)

pnegate() [12/47]

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pnegate

(

const Packet2cd &

a

)

pnegate() [13/47]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pnegate

(

const Packet2cf &

a

)

pnegate() [14/47]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pnegate

(

const Packet2cf &

a

)

pnegate() [15/47]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pnegate

(

const Packet2cf &

a

)

pnegate() [16/47]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pnegate

(

const Packet2cf &

a

)

pnegate() [17/47]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pnegate

(

const Packet2cf &

a

)

pnegate() [18/47]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pnegate

(

const Packet2d &

a

)

pnegate() [19/47]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pnegate

(

const Packet2d &

a

)

pnegate() [20/47]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pnegate

(

const Packet2d &

a

)

pnegate() [21/47]

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pnegate

(

const Packet2f &

a

)

pnegate() [22/47]

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pnegate

(

const Packet2i &

a

)

pnegate() [23/47]

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pnegate

(

const Packet2l &

a

)

pnegate() [24/47]

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pnegate

(

const Packet4c &

a

)

pnegate() [25/47]

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pnegate

(

const Packet4cd &

a

)

pnegate() [26/47]

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pnegate

(

const Packet4cf &

a

)

pnegate() [27/47]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pnegate

(

const Packet4d &

a

)

pnegate() [28/47]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pnegate

(

const Packet4f &

a

)

pnegate() [29/47]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pnegate

(

const Packet4f &

a

)

pnegate() [30/47]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pnegate

(

const Packet4f &

a

)

pnegate() [31/47]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pnegate

(

const Packet4f &

a

)

pnegate() [32/47]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pnegate

(

const Packet4f &

a

)

pnegate() [33/47]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pnegate

(

const Packet4i &

a

)

pnegate() [34/47]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pnegate

(

const Packet4i &

a

)

pnegate() [35/47]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pnegate

(

const Packet4i &

a

)

pnegate() [36/47]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pnegate

(

const Packet4i &

a

)

pnegate() [37/47]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pnegate

(

const Packet4i &

a

)

pnegate() [38/47]

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pnegate

(

const Packet4s &

a

)

pnegate() [39/47]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pnegate

(

const Packet8bf &

a

)

pnegate() [40/47]

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pnegate

(

const Packet8c &

a

)

pnegate() [41/47]

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pnegate

(

const Packet8cf &

a

)

pnegate() [42/47]

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pnegate

(

const Packet8d &

a

)

pnegate() [43/47]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pnegate

(

const Packet8f &

a

)

pnegate() [44/47]

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pnegate

(

const Packet8h &

a

)

pnegate() [45/47]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pnegate

(

const Packet8s &

a

)

pnegate() [46/47]

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pnegate

(

const PacketXf &

a

)

pnegate() [47/47]

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pnegate

(

const PacketXi &

a

)

pnegate< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pnegate< Packet4bf >

(

const Packet4bf &

a

)

pnegate< Packet8bf >()

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pnegate< Packet8bf >

(

const Packet8bf &

a

)

pnot()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pnot ( const Packet &  a )

inline

por() [1/6]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::por ( const Packet &  a, const Packet &  b  )

inline

por() [2/6]

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::por	(	const Packet16bf &	a,
		const Packet16bf &	b
	)

por() [3/6]

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::por	(	const Packet16h &	a,
		const Packet16h &	b
	)

por() [4/6]

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::por	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

por() [5/6]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::por	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

por() [6/6]

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::por	(	const Packet8h &	a,
		const Packet8h &	b
	)

por< Packet16b >()

template<>

EIGEN_STRONG_INLINE Packet16b Eigen::internal::por< Packet16b >	(	const Packet16b &	a,
		const Packet16b &	b
	)

por< Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::por< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

por< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::por< Packet16f >	(	const Packet16f &	a,
		const Packet16f &	b
	)

por< Packet16i >()

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::por< Packet16i >	(	const Packet16i &	a,
		const Packet16i &	b
	)

por< Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::por< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

por< Packet1cd >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::por< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

por< Packet1cd >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::por< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

por< Packet1cd >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::por< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

por< Packet1cf >()

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::por< Packet1cf >	(	const Packet1cf &	a,
		const Packet1cf &	b
	)

por< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::por< Packet2cd >	(	const Packet2cd &	a,
		const Packet2cd &	b
	)

por< Packet2cf >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::por< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

por< Packet2cf >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::por< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

por< Packet2cf >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::por< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

por< Packet2cf >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::por< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

por< Packet2cf >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::por< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

por< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::por< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

por< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::por< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

por< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::por< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

por< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::por< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

por< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::por< Packet2i >	(	const Packet2i &	a,
		const Packet2i &	b
	)

por< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::por< Packet2l >	(	const Packet2l &	a,
		const Packet2l &	b
	)

por< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::por< Packet2ui >	(	const Packet2ui &	a,
		const Packet2ui &	b
	)

por< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::por< Packet2ul >	(	const Packet2ul &	a,
		const Packet2ul &	b
	)

por< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::por< Packet4c >	(	const Packet4c &	a,
		const Packet4c &	b
	)

por< Packet4cd >()

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::por< Packet4cd >	(	const Packet4cd &	a,
		const Packet4cd &	b
	)

por< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::por< Packet4cf >	(	const Packet4cf &	a,
		const Packet4cf &	b
	)

por< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::por< Packet4d >	(	const Packet4d &	a,
		const Packet4d &	b
	)

por< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::por< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

por< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::por< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

por< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::por< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

por< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::por< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

por< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::por< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

por< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::por< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

por< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::por< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

por< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::por< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

por< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::por< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

por< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::por< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

por< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::por< Packet4s >	(	const Packet4s &	a,
		const Packet4s &	b
	)

por< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::por< Packet4uc >	(	const Packet4uc &	a,
		const Packet4uc &	b
	)

por< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::por< Packet4ui >	(	const Packet4ui &	a,
		const Packet4ui &	b
	)

por< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::por< Packet4us >	(	const Packet4us &	a,
		const Packet4us &	b
	)

por< Packet8bf >()

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::por< Packet8bf >	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

por< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::por< Packet8c >	(	const Packet8c &	a,
		const Packet8c &	b
	)

por< Packet8cf >()

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::por< Packet8cf >	(	const Packet8cf &	a,
		const Packet8cf &	b
	)

por< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::por< Packet8d >	(	const Packet8d &	a,
		const Packet8d &	b
	)

por< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::por< Packet8f >	(	const Packet8f &	a,
		const Packet8f &	b
	)

por< Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::por< Packet8i >	(	const Packet8i &	a,
		const Packet8i &	b
	)

por< Packet8s >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::por< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

por< Packet8s >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::por< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

por< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::por< Packet8uc >	(	const Packet8uc &	a,
		const Packet8uc &	b
	)

por< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::por< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

por< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::por< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

por< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::por< PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

por< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::por< PacketXi >	(	const PacketXi &	a,
		const PacketXi &	b
	)

positive_real_hypot()

template<typename RealScalar >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE RealScalar Eigen::internal::positive_real_hypot	(	const RealScalar &	x,
		const RealScalar &	y
	)

ppolygamma()

template<typename Packet >

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

predux()

template<typename Packet >

EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type Eigen::internal::predux ( const Packet &  a )

inline

predux< Packet16b >()

template<>

EIGEN_STRONG_INLINE bool Eigen::internal::predux< Packet16b >

(

const Packet16b &

a

)

predux< Packet16bf >()

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::predux< Packet16bf >

(

const Packet16bf &

p

)

predux< Packet16c >() [1/2]

template<>

EIGEN_STRONG_INLINE signed char Eigen::internal::predux< Packet16c >

(

const Packet16c &

a

)

predux< Packet16c >() [2/2]

template<>

EIGEN_STRONG_INLINE int8_t Eigen::internal::predux< Packet16c >

(

const Packet16c &

a

)

predux< Packet16f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet16f >

(

const Packet16f &

a

)

predux< Packet16h >()

template<>

EIGEN_STRONG_INLINE half Eigen::internal::predux< Packet16h >

(

const Packet16h &

from

)

predux< Packet16uc >() [1/2]

template<>

EIGEN_STRONG_INLINE unsigned char Eigen::internal::predux< Packet16uc >

(

const Packet16uc &

a

)

predux< Packet16uc >() [2/2]

template<>

EIGEN_STRONG_INLINE uint8_t Eigen::internal::predux< Packet16uc >

(

const Packet16uc &

a

)

predux< Packet1cd >() [1/3]

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux< Packet1cd >

(

const Packet1cd &

a

)

predux< Packet1cd >() [2/3]

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux< Packet1cd >

(

const Packet1cd &

a

)

predux< Packet1cd >() [3/3]

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux< Packet1cd >

(

const Packet1cd &

a

)

predux< Packet1cf >()

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux< Packet1cf >

(

const Packet1cf &

a

)

predux< Packet2cd >()

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux< Packet2cd >

(

const Packet2cd &

a

)

predux< Packet2cf >() [1/5]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux< Packet2cf >

(

const Packet2cf &

a

)

predux< Packet2cf >() [2/5]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux< Packet2cf >

(

const Packet2cf &

a

)

predux< Packet2cf >() [3/5]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux< Packet2cf >

(

const Packet2cf &

a

)

predux< Packet2cf >() [4/5]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux< Packet2cf >

(

const Packet2cf &

a

)

predux< Packet2cf >() [5/5]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux< Packet2cf >

(

const Packet2cf &

a

)

predux< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux< Packet2d >

(

const Packet2d &

a

)

predux< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux< Packet2d >

(

const Packet2d &

a

)

predux< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux< Packet2d >

(

const Packet2d &

a

)

predux< Packet2f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet2f >

(

const Packet2f &

a

)

predux< Packet2i >()

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::predux< Packet2i >

(

const Packet2i &

a

)

predux< Packet2l >()

template<>

EIGEN_STRONG_INLINE int64_t Eigen::internal::predux< Packet2l >

(

const Packet2l &

a

)

predux< Packet2ui >()

template<>

EIGEN_STRONG_INLINE uint32_t Eigen::internal::predux< Packet2ui >

(

const Packet2ui &

a

)

predux< Packet2ul >()

template<>

EIGEN_STRONG_INLINE uint64_t Eigen::internal::predux< Packet2ul >

(

const Packet2ul &

a

)

predux< Packet4bf >()

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::predux< Packet4bf >

(

const Packet4bf &

a

)

predux< Packet4c >()

template<>

EIGEN_STRONG_INLINE int8_t Eigen::internal::predux< Packet4c >

(

const Packet4c &

a

)

predux< Packet4cd >()

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux< Packet4cd >

(

const Packet4cd &

a

)

predux< Packet4cf >()

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux< Packet4cf >

(

const Packet4cf &

a

)

predux< Packet4d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux< Packet4d >

(

const Packet4d &

a

)

predux< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet4f >

(

const Packet4f &

a

)

predux< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet4f >

(

const Packet4f &

a

)

predux< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet4f >

(

const Packet4f &

a

)

predux< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet4f >

(

const Packet4f &

a

)

predux< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet4f >

(

const Packet4f &

a

)

predux< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux< Packet4i >

(

const Packet4i &

a

)

predux< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::predux< Packet4i >

(

const Packet4i &

a

)

predux< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::predux< Packet4i >

(

const Packet4i &

a

)

predux< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux< Packet4i >

(

const Packet4i &

a

)

predux< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux< Packet4i >

(

const Packet4i &

a

)

predux< Packet4s >()

template<>

EIGEN_STRONG_INLINE int16_t Eigen::internal::predux< Packet4s >

(

const Packet4s &

a

)

predux< Packet4uc >()

template<>

EIGEN_STRONG_INLINE uint8_t Eigen::internal::predux< Packet4uc >

(

const Packet4uc &

a

)

predux< Packet4ui >()

template<>

EIGEN_STRONG_INLINE uint32_t Eigen::internal::predux< Packet4ui >

(

const Packet4ui &

a

)

predux< Packet4us >()

template<>

EIGEN_STRONG_INLINE uint16_t Eigen::internal::predux< Packet4us >

(

const Packet4us &

a

)

predux< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::predux< Packet8bf >

(

const Packet8bf &

a

)

predux< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::predux< Packet8bf >

(

const Packet8bf &

a

)

predux< Packet8c >()

template<>

EIGEN_STRONG_INLINE int8_t Eigen::internal::predux< Packet8c >

(

const Packet8c &

a

)

predux< Packet8cf >()

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux< Packet8cf >

(

const Packet8cf &

a

)

predux< Packet8d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux< Packet8d >

(

const Packet8d &

a

)

predux< Packet8f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet8f >

(

const Packet8f &

a

)

predux< Packet8h >()

template<>

EIGEN_STRONG_INLINE Eigen::half Eigen::internal::predux< Packet8h >

(

const Packet8h &

a

)

predux< Packet8s >() [1/2]

template<>

EIGEN_STRONG_INLINE short int Eigen::internal::predux< Packet8s >

(

const Packet8s &

a

)

predux< Packet8s >() [2/2]

template<>

EIGEN_STRONG_INLINE int16_t Eigen::internal::predux< Packet8s >

(

const Packet8s &

a

)

predux< Packet8uc >()

template<>

EIGEN_STRONG_INLINE uint8_t Eigen::internal::predux< Packet8uc >

(

const Packet8uc &

a

)

predux< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE unsigned short int Eigen::internal::predux< Packet8us >

(

const Packet8us &

a

)

predux< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE uint16_t Eigen::internal::predux< Packet8us >

(

const Packet8us &

a

)

predux< PacketXf >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux< PacketXf >

(

const PacketXf &

a

)

predux< PacketXi >()

template<>

EIGEN_STRONG_INLINE numext::int32_t Eigen::internal::predux< PacketXi >

(

const PacketXi &

a

)

predux_any() [1/6]

template<typename Packet >

EIGEN_DEVICE_FUNC bool Eigen::internal::predux_any ( const Packet &  a )

inline

predux_any() [2/6]

template<>

EIGEN_STRONG_INLINE bool Eigen::internal::predux_any

(

const Packet16f &

x

)

predux_any() [3/6]

template<>

EIGEN_STRONG_INLINE bool Eigen::internal::predux_any

(

const Packet4f &

x

)

predux_any() [4/6]

template<>

EIGEN_STRONG_INLINE bool Eigen::internal::predux_any

(

const Packet4f &

x

)

predux_any() [5/6]

template<>

EIGEN_STRONG_INLINE bool Eigen::internal::predux_any

(

const Packet4f &

x

)

predux_any() [6/6]

template<>

EIGEN_STRONG_INLINE bool Eigen::internal::predux_any

(

const Packet8f &

x

)

predux_half_dowto4() [1/9]

template<typename Packet >

const DoublePacket< Packet > & Eigen::internal::predux_half_dowto4

(

const DoublePacket< Packet > &

a

)

predux_half_dowto4() [2/9]

template<typename Packet >

DoublePacket< typename unpacket_traits< Packet >::half > Eigen::internal::predux_half_dowto4	(	const DoublePacket< Packet > &	a,
		typename enable_if< unpacket_traits< Packet >::size==16 >::type *	= 0
	)

predux_half_dowto4() [3/9]

template<typename Packet >

EIGEN_DEVICE_FUNC conditional<(unpacket_traits< Packet >::size%8)==0, typenameunpacket_traits< Packet >::half, Packet >::type Eigen::internal::predux_half_dowto4 ( const Packet &  a )

inline

predux_half_dowto4() [4/9]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c Eigen::internal::predux_half_dowto4

(

const Packet16c &

a

)

predux_half_dowto4() [5/9]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc Eigen::internal::predux_half_dowto4

(

const Packet16uc &

a

)

predux_half_dowto4() [6/9]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4c Eigen::internal::predux_half_dowto4

(

const Packet8c &

a

)

predux_half_dowto4() [7/9]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s Eigen::internal::predux_half_dowto4

(

const Packet8s &

a

)

predux_half_dowto4() [8/9]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4uc Eigen::internal::predux_half_dowto4

(

const Packet8uc &

a

)

predux_half_dowto4() [9/9]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us Eigen::internal::predux_half_dowto4

(

const Packet8us &

a

)

predux_half_dowto4< Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::predux_half_dowto4< Packet16bf >

(

const Packet16bf &

a

)

predux_half_dowto4< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::predux_half_dowto4< Packet16f >

(

const Packet16f &

a

)

predux_half_dowto4< Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::predux_half_dowto4< Packet16h >

(

const Packet16h &

a

)

predux_half_dowto4< Packet8cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::predux_half_dowto4< Packet8cf >

(

const Packet8cf &

a

)

predux_half_dowto4< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::predux_half_dowto4< Packet8d >

(

const Packet8d &

a

)

predux_half_dowto4< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::predux_half_dowto4< Packet8f >

(

const Packet8f &

a

)

predux_helper()

template<typename Packet , typename Op >

EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type Eigen::internal::predux_helper ( const Packet &  a, Op  op  )

inline

predux_max() [1/2]

template<typename Packet >

EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type Eigen::internal::predux_max ( const Packet &  a )

inline

predux_max() [2/2]

template<int NaNPropagation, typename Packet >

EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type Eigen::internal::predux_max ( const Packet &  a )

inline

predux_max< Packet16bf >()

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::predux_max< Packet16bf >

(

const Packet16bf &

from

)

predux_max< Packet16c >() [1/2]

template<>

EIGEN_STRONG_INLINE signed char Eigen::internal::predux_max< Packet16c >

(

const Packet16c &

a

)

predux_max< Packet16c >() [2/2]

template<>

EIGEN_STRONG_INLINE int8_t Eigen::internal::predux_max< Packet16c >

(

const Packet16c &

a

)

predux_max< Packet16f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_max< Packet16f >

(

const Packet16f &

a

)

predux_max< Packet16h >()

template<>

EIGEN_STRONG_INLINE Eigen::half Eigen::internal::predux_max< Packet16h >

(

const Packet16h &

a

)

predux_max< Packet16uc >() [1/2]

template<>

EIGEN_STRONG_INLINE unsigned char Eigen::internal::predux_max< Packet16uc >

(

const Packet16uc &

a

)

predux_max< Packet16uc >() [2/2]

template<>

EIGEN_STRONG_INLINE uint8_t Eigen::internal::predux_max< Packet16uc >

(

const Packet16uc &

a

)

predux_max< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_max< Packet2d >

(

const Packet2d &

a

)

predux_max< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_max< Packet2d >

(

const Packet2d &

a

)

predux_max< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_max< Packet2d >

(

const Packet2d &

a

)

predux_max< Packet2f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_max< Packet2f >

(

const Packet2f &

a

)

predux_max< Packet2i >()

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::predux_max< Packet2i >

(

const Packet2i &

a

)

predux_max< Packet2l >()

template<>

EIGEN_STRONG_INLINE int64_t Eigen::internal::predux_max< Packet2l >

(

const Packet2l &

a

)

predux_max< Packet2ui >()

template<>

EIGEN_STRONG_INLINE uint32_t Eigen::internal::predux_max< Packet2ui >

(

const Packet2ui &

a

)

predux_max< Packet2ul >()

template<>

EIGEN_STRONG_INLINE uint64_t Eigen::internal::predux_max< Packet2ul >

(

const Packet2ul &

a

)

predux_max< Packet4bf >()

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::predux_max< Packet4bf >

(

const Packet4bf &

a

)

predux_max< Packet4c >()

template<>

EIGEN_STRONG_INLINE int8_t Eigen::internal::predux_max< Packet4c >

(

const Packet4c &

a

)

predux_max< Packet4d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_max< Packet4d >

(

const Packet4d &

a

)

predux_max< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_max< Packet4f >

(

const Packet4f &

a

)

predux_max< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_max< Packet4f >

(

const Packet4f &

a

)

predux_max< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_max< Packet4f >

(

const Packet4f &

a

)

predux_max< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_max< Packet4f >

(

const Packet4f &

a

)

predux_max< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_max< Packet4f >

(

const Packet4f &

a

)

predux_max< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_max< Packet4i >

(

const Packet4i &

a

)

predux_max< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::predux_max< Packet4i >

(

const Packet4i &

a

)

predux_max< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::predux_max< Packet4i >

(

const Packet4i &

a

)

predux_max< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_max< Packet4i >

(

const Packet4i &

a

)

predux_max< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_max< Packet4i >

(

const Packet4i &

a

)

predux_max< Packet4s >()

template<>

EIGEN_STRONG_INLINE int16_t Eigen::internal::predux_max< Packet4s >

(

const Packet4s &

a

)

predux_max< Packet4uc >()

template<>

EIGEN_STRONG_INLINE uint8_t Eigen::internal::predux_max< Packet4uc >

(

const Packet4uc &

a

)

predux_max< Packet4ui >()

template<>

EIGEN_STRONG_INLINE uint32_t Eigen::internal::predux_max< Packet4ui >

(

const Packet4ui &

a

)

predux_max< Packet4us >()

template<>

EIGEN_STRONG_INLINE uint16_t Eigen::internal::predux_max< Packet4us >

(

const Packet4us &

a

)

predux_max< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::predux_max< Packet8bf >

(

const Packet8bf &

a

)

predux_max< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::predux_max< Packet8bf >

(

const Packet8bf &

a

)

predux_max< Packet8c >()

template<>

EIGEN_STRONG_INLINE int8_t Eigen::internal::predux_max< Packet8c >

(

const Packet8c &

a

)

predux_max< Packet8d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_max< Packet8d >

(

const Packet8d &

a

)

predux_max< Packet8f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_max< Packet8f >

(

const Packet8f &

a

)

predux_max< Packet8h >()

template<>

EIGEN_STRONG_INLINE Eigen::half Eigen::internal::predux_max< Packet8h >

(

const Packet8h &

a

)

predux_max< Packet8s >() [1/2]

template<>

EIGEN_STRONG_INLINE short int Eigen::internal::predux_max< Packet8s >

(

const Packet8s &

a

)

predux_max< Packet8s >() [2/2]

template<>

EIGEN_STRONG_INLINE int16_t Eigen::internal::predux_max< Packet8s >

(

const Packet8s &

a

)

predux_max< Packet8uc >()

template<>

EIGEN_STRONG_INLINE uint8_t Eigen::internal::predux_max< Packet8uc >

(

const Packet8uc &

a

)

predux_max< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE unsigned short int Eigen::internal::predux_max< Packet8us >

(

const Packet8us &

a

)

predux_max< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE uint16_t Eigen::internal::predux_max< Packet8us >

(

const Packet8us &

a

)

predux_max< PacketXf >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_max< PacketXf >

(

const PacketXf &

a

)

predux_max< PacketXi >()

template<>

EIGEN_STRONG_INLINE numext::int32_t Eigen::internal::predux_max< PacketXi >

(

const PacketXi &

a

)

predux_min() [1/2]

template<typename Packet >

EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type Eigen::internal::predux_min ( const Packet &  a )

inline

predux_min() [2/2]

template<int NaNPropagation, typename Packet >

EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type Eigen::internal::predux_min ( const Packet &  a )

inline

predux_min< Packet16bf >()

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::predux_min< Packet16bf >

(

const Packet16bf &

from

)

predux_min< Packet16c >() [1/2]

template<>

EIGEN_STRONG_INLINE signed char Eigen::internal::predux_min< Packet16c >

(

const Packet16c &

a

)

predux_min< Packet16c >() [2/2]

template<>

EIGEN_STRONG_INLINE int8_t Eigen::internal::predux_min< Packet16c >

(

const Packet16c &

a

)

predux_min< Packet16f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_min< Packet16f >

(

const Packet16f &

a

)

predux_min< Packet16h >()

template<>

EIGEN_STRONG_INLINE Eigen::half Eigen::internal::predux_min< Packet16h >

(

const Packet16h &

a

)

predux_min< Packet16uc >() [1/2]

template<>

EIGEN_STRONG_INLINE unsigned char Eigen::internal::predux_min< Packet16uc >

(

const Packet16uc &

a

)

predux_min< Packet16uc >() [2/2]

template<>

EIGEN_STRONG_INLINE uint8_t Eigen::internal::predux_min< Packet16uc >

(

const Packet16uc &

a

)

predux_min< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_min< Packet2d >

(

const Packet2d &

a

)

predux_min< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_min< Packet2d >

(

const Packet2d &

a

)

predux_min< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_min< Packet2d >

(

const Packet2d &

a

)

predux_min< Packet2f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_min< Packet2f >

(

const Packet2f &

a

)

predux_min< Packet2i >()

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::predux_min< Packet2i >

(

const Packet2i &

a

)

predux_min< Packet2l >()

template<>

EIGEN_STRONG_INLINE int64_t Eigen::internal::predux_min< Packet2l >

(

const Packet2l &

a

)

predux_min< Packet2ui >()

template<>

EIGEN_STRONG_INLINE uint32_t Eigen::internal::predux_min< Packet2ui >

(

const Packet2ui &

a

)

predux_min< Packet2ul >()

template<>

EIGEN_STRONG_INLINE uint64_t Eigen::internal::predux_min< Packet2ul >

(

const Packet2ul &

a

)

predux_min< Packet4bf >()

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::predux_min< Packet4bf >

(

const Packet4bf &

a

)

predux_min< Packet4c >()

template<>

EIGEN_STRONG_INLINE int8_t Eigen::internal::predux_min< Packet4c >

(

const Packet4c &

a

)

predux_min< Packet4d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_min< Packet4d >

(

const Packet4d &

a

)

predux_min< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_min< Packet4f >

(

const Packet4f &

a

)

predux_min< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_min< Packet4f >

(

const Packet4f &

a

)

predux_min< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_min< Packet4f >

(

const Packet4f &

a

)

predux_min< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_min< Packet4f >

(

const Packet4f &

a

)

predux_min< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_min< Packet4f >

(

const Packet4f &

a

)

predux_min< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_min< Packet4i >

(

const Packet4i &

a

)

predux_min< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::predux_min< Packet4i >

(

const Packet4i &

a

)

predux_min< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::predux_min< Packet4i >

(

const Packet4i &

a

)

predux_min< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_min< Packet4i >

(

const Packet4i &

a

)

predux_min< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_min< Packet4i >

(

const Packet4i &

a

)

predux_min< Packet4s >()

template<>

EIGEN_STRONG_INLINE int16_t Eigen::internal::predux_min< Packet4s >

(

const Packet4s &

a

)

predux_min< Packet4uc >()

template<>

EIGEN_STRONG_INLINE uint8_t Eigen::internal::predux_min< Packet4uc >

(

const Packet4uc &

a

)

predux_min< Packet4ui >()

template<>

EIGEN_STRONG_INLINE uint32_t Eigen::internal::predux_min< Packet4ui >

(

const Packet4ui &

a

)

predux_min< Packet4us >()

template<>

EIGEN_STRONG_INLINE uint16_t Eigen::internal::predux_min< Packet4us >

(

const Packet4us &

a

)

predux_min< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::predux_min< Packet8bf >

(

const Packet8bf &

a

)

predux_min< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::predux_min< Packet8bf >

(

const Packet8bf &

a

)

predux_min< Packet8c >()

template<>

EIGEN_STRONG_INLINE int8_t Eigen::internal::predux_min< Packet8c >

(

const Packet8c &

a

)

predux_min< Packet8d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_min< Packet8d >

(

const Packet8d &

a

)

predux_min< Packet8f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_min< Packet8f >

(

const Packet8f &

a

)

predux_min< Packet8h >()

template<>

EIGEN_STRONG_INLINE Eigen::half Eigen::internal::predux_min< Packet8h >

(

const Packet8h &

a

)

predux_min< Packet8s >() [1/2]

template<>

EIGEN_STRONG_INLINE short int Eigen::internal::predux_min< Packet8s >

(

const Packet8s &

a

)

predux_min< Packet8s >() [2/2]

template<>

EIGEN_STRONG_INLINE int16_t Eigen::internal::predux_min< Packet8s >

(

const Packet8s &

a

)

predux_min< Packet8uc >()

template<>

EIGEN_STRONG_INLINE uint8_t Eigen::internal::predux_min< Packet8uc >

(

const Packet8uc &

a

)

predux_min< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE unsigned short int Eigen::internal::predux_min< Packet8us >

(

const Packet8us &

a

)

predux_min< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE uint16_t Eigen::internal::predux_min< Packet8us >

(

const Packet8us &

a

)

predux_min< PacketXf >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_min< PacketXf >

(

const PacketXf &

a

)

predux_min< PacketXi >()

template<>

EIGEN_STRONG_INLINE numext::int32_t Eigen::internal::predux_min< PacketXi >

(

const PacketXi &

a

)

predux_mul()

template<typename Packet >

EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type Eigen::internal::predux_mul ( const Packet &  a )

inline

predux_mul< Packet16b >()

template<>

EIGEN_STRONG_INLINE bool Eigen::internal::predux_mul< Packet16b >

(

const Packet16b &

a

)

predux_mul< Packet16bf >()

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::predux_mul< Packet16bf >

(

const Packet16bf &

from

)

predux_mul< Packet16c >() [1/2]

template<>

EIGEN_STRONG_INLINE signed char Eigen::internal::predux_mul< Packet16c >

(

const Packet16c &

a

)

predux_mul< Packet16c >() [2/2]

template<>

EIGEN_STRONG_INLINE int8_t Eigen::internal::predux_mul< Packet16c >

(

const Packet16c &

a

)

predux_mul< Packet16f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_mul< Packet16f >

(

const Packet16f &

a

)

predux_mul< Packet16h >()

template<>

EIGEN_STRONG_INLINE half Eigen::internal::predux_mul< Packet16h >

(

const Packet16h &

from

)

predux_mul< Packet16uc >() [1/2]

template<>

EIGEN_STRONG_INLINE unsigned char Eigen::internal::predux_mul< Packet16uc >

(

const Packet16uc &

a

)

predux_mul< Packet16uc >() [2/2]

template<>

EIGEN_STRONG_INLINE uint8_t Eigen::internal::predux_mul< Packet16uc >

(

const Packet16uc &

a

)

predux_mul< Packet1cd >() [1/3]

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux_mul< Packet1cd >

(

const Packet1cd &

a

)

predux_mul< Packet1cd >() [2/3]

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux_mul< Packet1cd >

(

const Packet1cd &

a

)

predux_mul< Packet1cd >() [3/3]

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux_mul< Packet1cd >

(

const Packet1cd &

a

)

predux_mul< Packet1cf >()

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux_mul< Packet1cf >

(

const Packet1cf &

a

)

predux_mul< Packet2cd >()

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux_mul< Packet2cd >

(

const Packet2cd &

a

)

predux_mul< Packet2cf >() [1/5]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux_mul< Packet2cf >

(

const Packet2cf &

a

)

predux_mul< Packet2cf >() [2/5]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux_mul< Packet2cf >

(

const Packet2cf &

a

)

predux_mul< Packet2cf >() [3/5]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux_mul< Packet2cf >

(

const Packet2cf &

a

)

predux_mul< Packet2cf >() [4/5]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux_mul< Packet2cf >

(

const Packet2cf &

a

)

predux_mul< Packet2cf >() [5/5]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux_mul< Packet2cf >

(

const Packet2cf &

a

)

predux_mul< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_mul< Packet2d >

(

const Packet2d &

a

)

predux_mul< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_mul< Packet2d >

(

const Packet2d &

a

)

predux_mul< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_mul< Packet2d >

(

const Packet2d &

a

)

predux_mul< Packet2f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_mul< Packet2f >

(

const Packet2f &

a

)

predux_mul< Packet2i >()

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::predux_mul< Packet2i >

(

const Packet2i &

a

)

predux_mul< Packet2l >()

template<>

EIGEN_STRONG_INLINE int64_t Eigen::internal::predux_mul< Packet2l >

(

const Packet2l &

a

)

predux_mul< Packet2ui >()

template<>

EIGEN_STRONG_INLINE uint32_t Eigen::internal::predux_mul< Packet2ui >

(

const Packet2ui &

a

)

predux_mul< Packet2ul >()

template<>

EIGEN_STRONG_INLINE uint64_t Eigen::internal::predux_mul< Packet2ul >

(

const Packet2ul &

a

)

predux_mul< Packet4bf >()

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::predux_mul< Packet4bf >

(

const Packet4bf &

a

)

predux_mul< Packet4c >()

template<>

EIGEN_STRONG_INLINE int8_t Eigen::internal::predux_mul< Packet4c >

(

const Packet4c &

a

)

predux_mul< Packet4cd >()

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux_mul< Packet4cd >

(

const Packet4cd &

a

)

predux_mul< Packet4cf >()

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux_mul< Packet4cf >

(

const Packet4cf &

a

)

predux_mul< Packet4d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_mul< Packet4d >

(

const Packet4d &

a

)

predux_mul< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_mul< Packet4f >

(

const Packet4f &

a

)

predux_mul< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_mul< Packet4f >

(

const Packet4f &

a

)

predux_mul< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_mul< Packet4f >

(

const Packet4f &

a

)

predux_mul< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_mul< Packet4f >

(

const Packet4f &

a

)

predux_mul< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_mul< Packet4f >

(

const Packet4f &

a

)

predux_mul< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_mul< Packet4i >

(

const Packet4i &

a

)

predux_mul< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::predux_mul< Packet4i >

(

const Packet4i &

a

)

predux_mul< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::predux_mul< Packet4i >

(

const Packet4i &

a

)

predux_mul< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_mul< Packet4i >

(

const Packet4i &

a

)

predux_mul< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_mul< Packet4i >

(

const Packet4i &

a

)

predux_mul< Packet4s >()

template<>

EIGEN_STRONG_INLINE int16_t Eigen::internal::predux_mul< Packet4s >

(

const Packet4s &

a

)

predux_mul< Packet4uc >()

template<>

EIGEN_STRONG_INLINE uint8_t Eigen::internal::predux_mul< Packet4uc >

(

const Packet4uc &

a

)

predux_mul< Packet4ui >()

template<>

EIGEN_STRONG_INLINE uint32_t Eigen::internal::predux_mul< Packet4ui >

(

const Packet4ui &

a

)

predux_mul< Packet4us >()

template<>

EIGEN_STRONG_INLINE uint16_t Eigen::internal::predux_mul< Packet4us >

(

const Packet4us &

a

)

predux_mul< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::predux_mul< Packet8bf >

(

const Packet8bf &

a

)

predux_mul< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE bfloat16 Eigen::internal::predux_mul< Packet8bf >

(

const Packet8bf &

a

)

predux_mul< Packet8c >()

template<>

EIGEN_STRONG_INLINE int8_t Eigen::internal::predux_mul< Packet8c >

(

const Packet8c &

a

)

predux_mul< Packet8cf >()

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux_mul< Packet8cf >

(

const Packet8cf &

a

)

predux_mul< Packet8d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_mul< Packet8d >

(

const Packet8d &

a

)

predux_mul< Packet8f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_mul< Packet8f >

(

const Packet8f &

a

)

predux_mul< Packet8h >()

template<>

EIGEN_STRONG_INLINE Eigen::half Eigen::internal::predux_mul< Packet8h >

(

const Packet8h &

a

)

predux_mul< Packet8s >() [1/2]

template<>

EIGEN_STRONG_INLINE short int Eigen::internal::predux_mul< Packet8s >

(

const Packet8s &

a

)

predux_mul< Packet8s >() [2/2]

template<>

EIGEN_STRONG_INLINE int16_t Eigen::internal::predux_mul< Packet8s >

(

const Packet8s &

a

)

predux_mul< Packet8uc >()

template<>

EIGEN_STRONG_INLINE uint8_t Eigen::internal::predux_mul< Packet8uc >

(

const Packet8uc &

a

)

predux_mul< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE unsigned short int Eigen::internal::predux_mul< Packet8us >

(

const Packet8us &

a

)

predux_mul< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE uint16_t Eigen::internal::predux_mul< Packet8us >

(

const Packet8us &

a

)

predux_mul< PacketXf >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_mul< PacketXf >

(

const PacketXf &

a

)

predux_mul< PacketXi >()

template<>

EIGEN_STRONG_INLINE numext::int32_t Eigen::internal::predux_mul< PacketXi >

(

const PacketXi &

a

)

prefetch()

template<typename Scalar >

EIGEN_DEVICE_FUNC void Eigen::internal::prefetch ( const Scalar *  addr )

inline

prefetch< double >() [1/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< double >

(

const double *

addr

)

prefetch< double >() [2/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< double >

(

const double *

addr

)

prefetch< double >() [3/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< double >

(

const double *

addr

)

prefetch< double >() [4/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< double >

(

const double *

addr

)

prefetch< double >() [5/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< double >

(

const double *

addr

)

prefetch< float >() [1/7]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< float >

(

const float *

addr

)

prefetch< float >() [2/7]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< float >

(

const float *

addr

)

prefetch< float >() [3/7]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< float >

(

const float *

addr

)

prefetch< float >() [4/7]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< float >

(

const float *

addr

)

prefetch< float >() [5/7]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< float >

(

const float *

addr

)

prefetch< float >() [6/7]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< float >

(

const float *

addr

)

prefetch< float >() [7/7]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< float >

(

const float *

addr

)

prefetch< int >() [1/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int >

(

const int *

addr

)

prefetch< int >() [2/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int >

(

const int *

addr

)

prefetch< int >() [3/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int >

(

const int *

addr

)

prefetch< int >() [4/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int >

(

const int *

addr

)

prefetch< int >() [5/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int >

(

const int *

addr

)

prefetch< int16_t >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int16_t >

(

const int16_t *

addr

)

prefetch< int32_t >() [1/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int32_t >

(

const int32_t *

addr

)

prefetch< int32_t >() [2/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int32_t >

(

const int32_t *

addr

)

prefetch< int64_t >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int64_t >

(

const int64_t *

addr

)

prefetch< int8_t >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int8_t >

(

const int8_t *

addr

)

prefetch< numext::int32_t >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< numext::int32_t >

(

const numext::int32_t *

addr

)

prefetch< std::complex< double > >() [1/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< std::complex< double > >

(

const std::complex< double > *

addr

)

prefetch< std::complex< double > >() [2/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< std::complex< double > >

(

const std::complex< double > *

addr

)

prefetch< std::complex< double > >() [3/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< std::complex< double > >

(

const std::complex< double > *

addr

)

prefetch< std::complex< float > >() [1/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< std::complex< float > >

(

const std::complex< float > *

addr

)

prefetch< std::complex< float > >() [2/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< std::complex< float > >

(

const std::complex< float > *

addr

)

prefetch< std::complex< float > >() [3/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< std::complex< float > >

(

const std::complex< float > *

addr

)

prefetch< std::complex< float > >() [4/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< std::complex< float > >

(

const std::complex< float > *

addr

)

prefetch< std::complex< float > >() [5/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< std::complex< float > >

(

const std::complex< float > *

addr

)

prefetch< uint16_t >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< uint16_t >

(

const uint16_t *

addr

)

prefetch< uint32_t >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< uint32_t >

(

const uint32_t *

addr

)

prefetch< uint64_t >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< uint64_t >

(

const uint64_t *

addr

)

prefetch< uint8_t >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< uint8_t >

(

const uint8_t *

addr

)

preinterpret()

template<typename Target , typename Packet >

EIGEN_DEVICE_FUNC Target Eigen::internal::preinterpret ( const Packet &  a )

inline

preinterpret< Packet16c, Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::preinterpret< Packet16c, Packet16uc >

(

const Packet16uc &

a

)

preinterpret< Packet16f, Packet16i >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::preinterpret< Packet16f, Packet16i >

(

const Packet16i &

a

)

preinterpret< Packet16i, Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::preinterpret< Packet16i, Packet16f >

(

const Packet16f &

a

)

preinterpret< Packet16uc, Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::preinterpret< Packet16uc, Packet16c >

(

const Packet16c &

a

)

preinterpret< Packet2d, Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::preinterpret< Packet2d, Packet4i >

(

const Packet4i &

a

)

preinterpret< Packet2f, Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::preinterpret< Packet2f, Packet2i >

(

const Packet2i &

a

)

preinterpret< Packet2f, Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::preinterpret< Packet2f, Packet2ui >

(

const Packet2ui &

a

)

preinterpret< Packet2i, Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::preinterpret< Packet2i, Packet2f >

(

const Packet2f &

a

)

preinterpret< Packet2i, Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::preinterpret< Packet2i, Packet2ui >

(

const Packet2ui &

a

)

preinterpret< Packet2l, Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::preinterpret< Packet2l, Packet2ul >

(

const Packet2ul &

a

)

preinterpret< Packet2ui, Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::preinterpret< Packet2ui, Packet2f >

(

const Packet2f &

a

)

preinterpret< Packet2ui, Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::preinterpret< Packet2ui, Packet2i >

(

const Packet2i &

a

)

preinterpret< Packet2ul, Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::preinterpret< Packet2ul, Packet2l >

(

const Packet2l &

a

)

preinterpret< Packet4c, Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::preinterpret< Packet4c, Packet4uc >

(

const Packet4uc &

a

)

preinterpret< Packet4f, Packet4i >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::preinterpret< Packet4f, Packet4i >

(

const Packet4i &

a

)

preinterpret< Packet4f, Packet4i >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::preinterpret< Packet4f, Packet4i >

(

const Packet4i &

a

)

preinterpret< Packet4f, Packet4i >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::preinterpret< Packet4f, Packet4i >

(

const Packet4i &

a

)

preinterpret< Packet4f, Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::preinterpret< Packet4f, Packet4ui >

(

const Packet4ui &

a

)

preinterpret< Packet4i, Packet2d >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preinterpret< Packet4i, Packet2d >

(

const Packet2d &

a

)

preinterpret< Packet4i, Packet4f >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preinterpret< Packet4i, Packet4f >

(

const Packet4f &

a

)

preinterpret< Packet4i, Packet4f >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preinterpret< Packet4i, Packet4f >

(

const Packet4f &

a

)

preinterpret< Packet4i, Packet4f >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preinterpret< Packet4i, Packet4f >

(

const Packet4f &

a

)

preinterpret< Packet4i, Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preinterpret< Packet4i, Packet4ui >

(

const Packet4ui &

a

)

preinterpret< Packet4s, Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::preinterpret< Packet4s, Packet4us >

(

const Packet4us &

a

)

preinterpret< Packet4uc, Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::preinterpret< Packet4uc, Packet4c >

(

const Packet4c &

a

)

preinterpret< Packet4ui, Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::preinterpret< Packet4ui, Packet4f >

(

const Packet4f &

a

)

preinterpret< Packet4ui, Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::preinterpret< Packet4ui, Packet4i >

(

const Packet4i &

a

)

preinterpret< Packet4us, Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::preinterpret< Packet4us, Packet4s >

(

const Packet4s &

a

)

preinterpret< Packet8c, Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::preinterpret< Packet8c, Packet8uc >

(

const Packet8uc &

a

)

preinterpret< Packet8f, Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::preinterpret< Packet8f, Packet8i >

(

const Packet8i &

a

)

preinterpret< Packet8i, Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::preinterpret< Packet8i, Packet8f >

(

const Packet8f &

a

)

preinterpret< Packet8s, Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::preinterpret< Packet8s, Packet8us >

(

const Packet8us &

a

)

preinterpret< Packet8uc, Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::preinterpret< Packet8uc, Packet8c >

(

const Packet8c &

a

)

preinterpret< Packet8us, Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::preinterpret< Packet8us, Packet8s >

(

const Packet8s &

a

)

preinterpret< PacketXf, PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::preinterpret< PacketXf, PacketXi >

(

const PacketXi &

a

)

preinterpret< PacketXi, PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::preinterpret< PacketXi, PacketXf >

(

const PacketXf &

a

)

preverse() [1/59]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::preverse ( const Packet &  a )

inline

preverse() [2/59]

template<>

EIGEN_STRONG_INLINE Packet16b Eigen::internal::preverse

(

const Packet16b &

a

)

preverse() [3/59]

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::preverse

(

const Packet16bf &

a

)

preverse() [4/59]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::preverse

(

const Packet16c &

a

)

preverse() [5/59]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::preverse

(

const Packet16c &

a

)

preverse() [6/59]

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::preverse

(

const Packet16f &

a

)

preverse() [7/59]

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::preverse

(

const Packet16h &

a

)

preverse() [8/59]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::preverse

(

const Packet16uc &

a

)

preverse() [9/59]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::preverse

(

const Packet16uc &

a

)

preverse() [10/59]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::preverse

(

const Packet1cd &

a

)

preverse() [11/59]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::preverse

(

const Packet1cd &

a

)

preverse() [12/59]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::preverse

(

const Packet1cd &

a

)

preverse() [13/59]

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::preverse

(

const Packet1cf &

a

)

preverse() [14/59]

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::preverse

(

const Packet2cd &

a

)

preverse() [15/59]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::preverse

(

const Packet2cf &

a

)

preverse() [16/59]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::preverse

(

const Packet2cf &

a

)

preverse() [17/59]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::preverse

(

const Packet2cf &

a

)

preverse() [18/59]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::preverse

(

const Packet2cf &

a

)

preverse() [19/59]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::preverse

(

const Packet2cf &

a

)

preverse() [20/59]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::preverse

(

const Packet2d &

a

)

preverse() [21/59]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::preverse

(

const Packet2d &

a

)

preverse() [22/59]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::preverse

(

const Packet2d &

a

)

preverse() [23/59]

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::preverse

(

const Packet2f &

a

)

preverse() [24/59]

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::preverse

(

const Packet2i &

a

)

preverse() [25/59]

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::preverse

(

const Packet2l &

a

)

preverse() [26/59]

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::preverse

(

const Packet2ui &

a

)

preverse() [27/59]

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::preverse

(

const Packet2ul &

a

)

preverse() [28/59]

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::preverse

(

const Packet4c &

a

)

preverse() [29/59]

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::preverse

(

const Packet4cd &

a

)

preverse() [30/59]

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::preverse

(

const Packet4cf &

a

)

preverse() [31/59]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::preverse

(

const Packet4d &

a

)

preverse() [32/59]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::preverse

(

const Packet4f &

a

)

preverse() [33/59]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::preverse

(

const Packet4f &

a

)

preverse() [34/59]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::preverse

(

const Packet4f &

a

)

preverse() [35/59]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::preverse

(

const Packet4f &

a

)

preverse() [36/59]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::preverse

(

const Packet4f &

a

)

preverse() [37/59]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preverse

(

const Packet4i &

a

)

preverse() [38/59]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preverse

(

const Packet4i &

a

)

preverse() [39/59]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preverse

(

const Packet4i &

a

)

preverse() [40/59]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preverse

(

const Packet4i &

a

)

preverse() [41/59]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preverse

(

const Packet4i &

a

)

preverse() [42/59]

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::preverse

(

const Packet4s &

a

)

preverse() [43/59]

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::preverse

(

const Packet4uc &

a

)

preverse() [44/59]

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::preverse

(

const Packet4ui &

a

)

preverse() [45/59]

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::preverse

(

const Packet4us &

a

)

preverse() [46/59]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::preverse

(

const Packet8bf &

a

)

preverse() [47/59]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::preverse

(

const Packet8bf &

a

)

preverse() [48/59]

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::preverse

(

const Packet8c &

a

)

preverse() [49/59]

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::preverse

(

const Packet8cf &

a

)

preverse() [50/59]

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::preverse

(

const Packet8d &

a

)

preverse() [51/59]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::preverse

(

const Packet8f &

a

)

preverse() [52/59]

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::preverse

(

const Packet8h &

a

)

preverse() [53/59]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::preverse

(

const Packet8s &

a

)

preverse() [54/59]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::preverse

(

const Packet8s &

a

)

preverse() [55/59]

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::preverse

(

const Packet8uc &

a

)

preverse() [56/59]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::preverse

(

const Packet8us &

a

)

preverse() [57/59]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::preverse

(

const Packet8us &

a

)

preverse() [58/59]

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::preverse

(

const PacketXf &

a

)

preverse() [59/59]

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::preverse

(

const PacketXi &

a

)

preverse< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::preverse< Packet4bf >

(

const Packet4bf &

a

)

print() [1/5]

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::print

(

const Packet &

a

)

print() [2/5]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::print

(

const Packet2d &

a

)

print() [3/5]

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::print

(

const Packet2f &

a

)

print() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::print

(

const Packet4f &

a

)

print() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::print

(

const Packet4f &

a

)

print< Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::print< Packet16bf >

(

const Packet16bf &

a

)

print< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::print< Packet16f >

(

const Packet16f &

a

)

print< Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::print< Packet16h >

(

const Packet16h &

a

)

print< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::print< Packet4bf >

(

const Packet4bf &

a

)

print< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::print< Packet4d >

(

const Packet4d &

a

)

print< Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::print< Packet4f >

(

const Packet4f &

a

)

print< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::print< Packet8bf >

(

const Packet8bf &

a

)

print< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::print< Packet8bf >

(

const Packet8bf &

a

)

print< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::print< Packet8d >

(

const Packet8d &

a

)

print< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::print< Packet8f >

(

const Packet8f &

a

)

print< Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::print< Packet8h >

(

const Packet8h &

a

)

print_matrix()

template<typename Derived >

std::ostream & Eigen::internal::print_matrix	(	std::ostream &	s,
		const Derived &	_m,
		const IOFormat &	fmt
	)

pround()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pround

(

const Packet &

a

)

pround< Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pround< Packet16bf >

(

const Packet16bf &

a

)

pround< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pround< Packet16f >

(

const Packet16f &

a

)

pround< Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pround< Packet16h >

(

const Packet16h &

a

)

pround< Packet2d >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pround< Packet2d >

(

const Packet2d &

a

)

pround< Packet2d >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pround< Packet2d >

(

const Packet2d &

a

)

pround< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pround< Packet4d >

(

const Packet4d &

a

)

pround< Packet4f >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pround< Packet4f >

(

const Packet4f &

a

)

pround< Packet4f >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pround< Packet4f >

(

const Packet4f &

a

)

pround< Packet4f >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pround< Packet4f >

(

const Packet4f &

a

)

pround< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pround< Packet8bf >

(

const Packet8bf &

a

)

pround< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pround< Packet8bf >

(

const Packet8bf &

a

)

pround< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pround< Packet8d >

(

const Packet8d &

a

)

pround< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pround< Packet8f >

(

const Packet8f &

a

)

pround< Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pround< Packet8h >

(

const Packet8h &

a

)

prsqrt() [1/5]

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::prsqrt

(

const Packet &

a

)

prsqrt() [2/5]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::prsqrt

(

const Packet2d &

a

)

prsqrt() [3/5]

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::prsqrt

(

const Packet2f &

a

)

prsqrt() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::prsqrt

(

const Packet4f &

a

)

prsqrt() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::prsqrt

(

const Packet4f &

a

)

prsqrt< Packet2d >() [1/2]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d Eigen::internal::prsqrt< Packet2d >

(

const Packet2d &

x

)

prsqrt< Packet2d >() [2/2]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d Eigen::internal::prsqrt< Packet2d >

(

const Packet2d &

x

)

prsqrt< Packet4d >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d Eigen::internal::prsqrt< Packet4d >

(

const Packet4d &

_x

)

prsqrt< Packet4f >() [1/3]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::prsqrt< Packet4f >

(

const Packet4f &

x

)

prsqrt< Packet4f >() [2/3]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::prsqrt< Packet4f >

(

const Packet4f &

x

)

prsqrt< Packet4f >() [3/3]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::prsqrt< Packet4f >

(

const Packet4f &

x

)

prsqrt< Packet8bf >()

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::prsqrt< Packet8bf >

(

const Packet8bf &

a

)

prsqrt< Packet8f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f Eigen::internal::prsqrt< Packet8f >

(

const Packet8f &

_x

)

pscatter()

template<typename Scalar , typename Packet >

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter ( Scalar *  to, const Packet &  from, Index    )

inline

pscatter< bfloat16, Packet16bf >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pscatter< bfloat16, Packet16bf >	(	bfloat16 *	to,
		const Packet16bf &	from,
		Index	stride
	)

pscatter< bfloat16, Packet4bf >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pscatter< bfloat16, Packet4bf >	(	bfloat16 *	to,
		const Packet4bf &	from,
		Index	stride
	)

pscatter< bfloat16, Packet8bf >() [1/2]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< bfloat16, Packet8bf > ( bfloat16 *  to, const Packet8bf &  from, Index  stride  )

inline

pscatter< bfloat16, Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pscatter< bfloat16, Packet8bf >	(	bfloat16 *	to,
		const Packet8bf &	from,
		Index	stride
	)

pscatter< bool, Packet16b >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< bool, Packet16b > ( bool *  to, const Packet16b &  from, Index  stride  )

inline

pscatter< double, Packet2d >() [1/3]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< double, Packet2d > ( double *  to, const Packet2d &  from, Index  stride  )

inline

pscatter< double, Packet2d >() [2/3]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< double, Packet2d > ( double *  to, const Packet2d &  from, Index  stride  )

inline

pscatter< double, Packet2d >() [3/3]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< double, Packet2d > ( double *  to, const Packet2d &  from, Index  stride  )

inline

pscatter< double, Packet4d >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< double, Packet4d > ( double *  to, const Packet4d &  from, Index  stride  )

inline

pscatter< double, Packet8d >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< double, Packet8d > ( double *  to, const Packet8d &  from, Index  stride  )

inline

pscatter< Eigen::half, Packet8h >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pscatter< Eigen::half, Packet8h >	(	Eigen::half *	to,
		const Packet8h &	from,
		Index	stride
	)

pscatter< float, Packet16f >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, Packet16f > ( float *  to, const Packet16f &  from, Index  stride  )

inline

pscatter< float, Packet2f >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< float, Packet2f >	(	float *	to,
		const Packet2f &	from,
		Index	stride
	)

pscatter< float, Packet4f >() [1/5]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, Packet4f > ( float *  to, const Packet4f &  from, Index  stride  )

inline

pscatter< float, Packet4f >() [2/5]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, Packet4f > ( float *  to, const Packet4f &  from, Index  stride  )

inline

pscatter< float, Packet4f >() [3/5]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< float, Packet4f >	(	float *	to,
		const Packet4f &	from,
		Index	stride
	)

pscatter< float, Packet4f >() [4/5]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, Packet4f > ( float *  to, const Packet4f &  from, Index  stride  )

inline

pscatter< float, Packet4f >() [5/5]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, Packet4f > ( float *  to, const Packet4f &  from, Index  stride  )

inline

pscatter< float, Packet8f >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, Packet8f > ( float *  to, const Packet8f &  from, Index  stride  )

inline

pscatter< float, PacketXf >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, PacketXf > ( float *  to, const PacketXf &  from, Index  stride  )

inline

pscatter< half, Packet16h >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pscatter< half, Packet16h >	(	half *	to,
		const Packet16h &	from,
		Index	stride
	)

pscatter< int, Packet4i >() [1/3]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< int, Packet4i > ( int *  to, const Packet4i &  from, Index  stride  )

inline

pscatter< int, Packet4i >() [2/3]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< int, Packet4i > ( int *  to, const Packet4i &  from, Index  stride  )

inline

pscatter< int, Packet4i >() [3/3]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< int, Packet4i > ( int *  to, const Packet4i &  from, Index  stride  )

inline

pscatter< int16_t, Packet4s >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< int16_t, Packet4s >	(	int16_t *	to,
		const Packet4s &	from,
		Index	stride
	)

pscatter< int16_t, Packet8s >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< int16_t, Packet8s >	(	int16_t *	to,
		const Packet8s &	from,
		Index	stride
	)

pscatter< int32_t, Packet2i >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< int32_t, Packet2i >	(	int32_t *	to,
		const Packet2i &	from,
		Index	stride
	)

pscatter< int32_t, Packet4i >() [1/2]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< int32_t, Packet4i > ( int32_t *  to, const Packet4i &  from, Index  stride  )

inline

pscatter< int32_t, Packet4i >() [2/2]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< int32_t, Packet4i >	(	int32_t *	to,
		const Packet4i &	from,
		Index	stride
	)

pscatter< int64_t, Packet2l >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< int64_t, Packet2l >	(	int64_t *	to,
		const Packet2l &	from,
		Index	stride
	)

pscatter< int8_t, Packet16c >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< int8_t, Packet16c >	(	int8_t *	to,
		const Packet16c &	from,
		Index	stride
	)

pscatter< int8_t, Packet4c >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< int8_t, Packet4c >	(	int8_t *	to,
		const Packet4c &	from,
		Index	stride
	)

pscatter< int8_t, Packet8c >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< int8_t, Packet8c >	(	int8_t *	to,
		const Packet8c &	from,
		Index	stride
	)

pscatter< numext::int32_t, PacketXi >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< numext::int32_t, PacketXi > ( numext::int32_t *  to, const PacketXi &  from, Index  stride  )

inline

pscatter< short int, Packet8s >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< short int, Packet8s > ( short int *  to, const Packet8s &  from, Index  stride  )

inline

pscatter< signed char, Packet16c >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< signed char, Packet16c > ( signed char *  to, const Packet16c &  from, Index  stride  )

inline

pscatter< std::complex< double >, Packet1cd >() [1/2]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< double >, Packet1cd > ( std::complex< double > *  to, const Packet1cd &  from, Index stride   __attribute__(unused)  )

inline

pscatter< std::complex< double >, Packet1cd >() [2/2]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< double >, Packet1cd > ( std::complex< double > *  to, const Packet1cd &  from, Index stride  EIGEN_UNUSED  )

inline

pscatter< std::complex< double >, Packet2cd >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< double >, Packet2cd > ( std::complex< double > *  to, const Packet2cd &  from, Index  stride  )

inline

pscatter< std::complex< double >, Packet4cd >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< double >, Packet4cd > ( std::complex< double > *  to, const Packet4cd &  from, Index  stride  )

inline

pscatter< std::complex< float >, Packet1cf >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< float >, Packet1cf > ( std::complex< float > *  to, const Packet1cf &  from, Index  stride  )

inline

pscatter< std::complex< float >, Packet2cf >() [1/5]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< float >, Packet2cf > ( std::complex< float > *  to, const Packet2cf &  from, Index  stride  )

inline

pscatter< std::complex< float >, Packet2cf >() [2/5]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< float >, Packet2cf > ( std::complex< float > *  to, const Packet2cf &  from, Index  stride  )

inline

pscatter< std::complex< float >, Packet2cf >() [3/5]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< float >, Packet2cf > ( std::complex< float > *  to, const Packet2cf &  from, Index  stride  )

inline

pscatter< std::complex< float >, Packet2cf >() [4/5]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< float >, Packet2cf > ( std::complex< float > *  to, const Packet2cf &  from, Index  stride  )

inline

pscatter< std::complex< float >, Packet2cf >() [5/5]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< float >, Packet2cf > ( std::complex< float > *  to, const Packet2cf &  from, Index  stride  )

inline

pscatter< std::complex< float >, Packet4cf >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< float >, Packet4cf > ( std::complex< float > *  to, const Packet4cf &  from, Index  stride  )

inline

pscatter< std::complex< float >, Packet8cf >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< float >, Packet8cf > ( std::complex< float > *  to, const Packet8cf &  from, Index  stride  )

inline

pscatter< uint16_t, Packet4us >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< uint16_t, Packet4us >	(	uint16_t *	to,
		const Packet4us &	from,
		Index	stride
	)

pscatter< uint16_t, Packet8us >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< uint16_t, Packet8us >	(	uint16_t *	to,
		const Packet8us &	from,
		Index	stride
	)

pscatter< uint32_t, Packet2ui >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< uint32_t, Packet2ui >	(	uint32_t *	to,
		const Packet2ui &	from,
		Index	stride
	)

pscatter< uint32_t, Packet4ui >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< uint32_t, Packet4ui >	(	uint32_t *	to,
		const Packet4ui &	from,
		Index	stride
	)

pscatter< uint64_t, Packet2ul >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< uint64_t, Packet2ul >	(	uint64_t *	to,
		const Packet2ul &	from,
		Index	stride
	)

pscatter< uint8_t, Packet16uc >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< uint8_t, Packet16uc >	(	uint8_t *	to,
		const Packet16uc &	from,
		Index	stride
	)

pscatter< uint8_t, Packet4uc >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< uint8_t, Packet4uc >	(	uint8_t *	to,
		const Packet4uc &	from,
		Index	stride
	)

pscatter< uint8_t, Packet8uc >()

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< uint8_t, Packet8uc >	(	uint8_t *	to,
		const Packet8uc &	from,
		Index	stride
	)

pscatter< unsigned char, Packet16uc >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< unsigned char, Packet16uc > ( unsigned char *  to, const Packet16uc &  from, Index  stride  )

inline

pscatter< unsigned short int, Packet8us >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< unsigned short int, Packet8us > ( unsigned short int *  to, const Packet8us &  from, Index  stride  )

inline

pscatter_size16()

template<typename Packet >

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter_size16 ( __UNPACK_TYPE__(Packet) *  to, const Packet &  from, Index  stride  )

inline

pscatter_size4()

template<typename Packet >

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter_size4 ( __UNPACK_TYPE__(Packet) *  to, const Packet &  from, Index  stride  )

inline

pscatter_size8()

template<typename Packet >

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter_size8 ( __UNPACK_TYPE__(Packet) *  to, const Packet &  from, Index  stride  )

inline

pselect() [1/26]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pselect ( const Packet &  mask, const Packet &  a, const Packet &  b  )

inline

pselect() [2/26]

template<>

EIGEN_DEVICE_FUNC Packet16b Eigen::internal::pselect ( const Packet16b &  mask, const Packet16b &  a, const Packet16b &  b  )

inline

pselect() [3/26]

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pselect	(	const Packet16bf &	mask,
		const Packet16bf &	a,
		const Packet16bf &	b
	)

pselect() [4/26]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16c Eigen::internal::pselect	(	const Packet16c &	mask,
		const Packet16c &	a,
		const Packet16c &	b
	)

pselect() [5/26]

template<>

EIGEN_DEVICE_FUNC Packet16f Eigen::internal::pselect ( const Packet16f &  mask, const Packet16f &  a, const Packet16f &  b  )

inline

pselect() [6/26]

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pselect	(	const Packet16h &	mask,
		const Packet16h &	a,
		const Packet16h &	b
	)

pselect() [7/26]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pselect	(	const Packet16uc &	mask,
		const Packet16uc &	a,
		const Packet16uc &	b
	)

pselect() [8/26]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2f Eigen::internal::pselect	(	const Packet2f &	mask,
		const Packet2f &	a,
		const Packet2f &	b
	)

pselect() [9/26]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2i Eigen::internal::pselect	(	const Packet2i &	mask,
		const Packet2i &	a,
		const Packet2i &	b
	)

pselect() [10/26]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2l Eigen::internal::pselect	(	const Packet2l &	mask,
		const Packet2l &	a,
		const Packet2l &	b
	)

pselect() [11/26]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pselect	(	const Packet2ui &	mask,
		const Packet2ui &	a,
		const Packet2ui &	b
	)

pselect() [12/26]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pselect	(	const Packet2ul &	mask,
		const Packet2ul &	a,
		const Packet2ul &	b
	)

pselect() [13/26]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pselect	(	const Packet4bf &	mask,
		const Packet4bf &	a,
		const Packet4bf &	b
	)

pselect() [14/26]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pselect	(	const Packet4f &	mask,
		const Packet4f &	a,
		const Packet4f &	b
	)

pselect() [15/26]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4f Eigen::internal::pselect	(	const Packet4f &	mask,
		const Packet4f &	a,
		const Packet4f &	b
	)

pselect() [16/26]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4i Eigen::internal::pselect	(	const Packet4i &	mask,
		const Packet4i &	a,
		const Packet4i &	b
	)

pselect() [17/26]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s Eigen::internal::pselect	(	const Packet4s &	mask,
		const Packet4s &	a,
		const Packet4s &	b
	)

pselect() [18/26]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pselect	(	const Packet4ui &	mask,
		const Packet4ui &	a,
		const Packet4ui &	b
	)

pselect() [19/26]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us Eigen::internal::pselect	(	const Packet4us &	mask,
		const Packet4us &	a,
		const Packet4us &	b
	)

pselect() [20/26]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pselect	(	const Packet8bf &	mask,
		const Packet8bf &	a,
		const Packet8bf &	b
	)

pselect() [21/26]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c Eigen::internal::pselect	(	const Packet8c &	mask,
		const Packet8c &	a,
		const Packet8c &	b
	)

pselect() [22/26]

template<>

EIGEN_DEVICE_FUNC Packet8d Eigen::internal::pselect ( const Packet8d &  mask, const Packet8d &  a, const Packet8d &  b  )

inline

pselect() [23/26]

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pselect	(	const Packet8h &	mask,
		const Packet8h &	a,
		const Packet8h &	b
	)

pselect() [24/26]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8s Eigen::internal::pselect	(	const Packet8s &	mask,
		const Packet8s &	a,
		const Packet8s &	b
	)

pselect() [25/26]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pselect	(	const Packet8uc &	mask,
		const Packet8uc &	a,
		const Packet8uc &	b
	)

pselect() [26/26]

template<>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8us Eigen::internal::pselect	(	const Packet8us &	mask,
		const Packet8us &	a,
		const Packet8us &	b
	)

pselect< bool >()

template<>

EIGEN_DEVICE_FUNC bool Eigen::internal::pselect< bool > ( const bool &  cond, const bool &  a, const bool &  b  )

inline

pselect< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pselect< Packet4d >	(	const Packet4d &	mask,
		const Packet4d &	a,
		const Packet4d &	b
	)

pselect< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pselect< Packet8f >	(	const Packet8f &	mask,
		const Packet8f &	a,
		const Packet8f &	b
	)

pset1()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pset1 ( const typename unpacket_traits< Packet >::type &  a )

inline

pset1< Packet16b >()

template<>

EIGEN_STRONG_INLINE Packet16b Eigen::internal::pset1< Packet16b >

(

const bool &

from

)

pset1< Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pset1< Packet16bf >

(

const bfloat16 &

from

)

pset1< Packet16c >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pset1< Packet16c >

(

const int8_t &

from

)

pset1< Packet16c >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pset1< Packet16c >

(

const signed char &

from

)

pset1< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pset1< Packet16f >

(

const float &

from

)

pset1< Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pset1< Packet16h >

(

const Eigen::half &

from

)

pset1< Packet16i >()

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::pset1< Packet16i >

(

const int &

from

)

pset1< Packet16uc >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pset1< Packet16uc >

(

const uint8_t &

from

)

pset1< Packet16uc >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pset1< Packet16uc >

(

const unsigned char &

from

)

pset1< Packet1cd >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pset1< Packet1cd >

(

const std::complex< double > &

from

)

pset1< Packet1cd >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pset1< Packet1cd >

(

const std::complex< double > &

from

)

pset1< Packet1cd >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pset1< Packet1cd >

(

const std::complex< double > &

from

)

pset1< Packet1cf >()

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pset1< Packet1cf >

(

const std::complex< float > &

from

)

pset1< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pset1< Packet2cd >

(

const std::complex< double > &

from

)

pset1< Packet2cf >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pset1< Packet2cf >

(

const std::complex< float > &

from

)

pset1< Packet2cf >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pset1< Packet2cf >

(

const std::complex< float > &

from

)

pset1< Packet2cf >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pset1< Packet2cf >

(

const std::complex< float > &

from

)

pset1< Packet2cf >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pset1< Packet2cf >

(

const std::complex< float > &

from

)

pset1< Packet2cf >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pset1< Packet2cf >

(

const std::complex< float > &

from

)

pset1< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pset1< Packet2d >

(

const double &

from

)

pset1< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pset1< Packet2d >

(

const double &

from

)

pset1< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pset1< Packet2d >

(

const double &

from

)

pset1< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pset1< Packet2f >

(

const float &

from

)

pset1< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pset1< Packet2i >

(

const int32_t &

from

)

pset1< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pset1< Packet2l >

(

const int64_t &

from

)

pset1< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pset1< Packet2ui >

(

const uint32_t &

from

)

pset1< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pset1< Packet2ul >

(

const uint64_t &

from

)

pset1< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pset1< Packet4bf >

(

const bfloat16 &

from

)

pset1< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pset1< Packet4c >

(

const int8_t &

from

)

pset1< Packet4cd >()

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pset1< Packet4cd >

(

const std::complex< double > &

from

)

pset1< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pset1< Packet4cf >

(

const std::complex< float > &

from

)

pset1< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pset1< Packet4d >

(

const double &

from

)

pset1< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pset1< Packet4f >

(

const float &

from

)

pset1< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pset1< Packet4f >

(

const float &

from

)

pset1< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pset1< Packet4f >

(

const float &

from

)

pset1< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pset1< Packet4f >

(

const float &

from

)

pset1< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pset1< Packet4f >

(

const float &

from

)

pset1< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pset1< Packet4i >

(

const int &

from

)

pset1< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pset1< Packet4i >

(

const int &

from

)

pset1< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pset1< Packet4i >

(

const int &

from

)

pset1< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pset1< Packet4i >

(

const int32_t &

from

)

pset1< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pset1< Packet4i >

(

const int32_t &

from

)

pset1< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pset1< Packet4s >

(

const int16_t &

from

)

pset1< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pset1< Packet4uc >

(

const uint8_t &

from

)

pset1< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pset1< Packet4ui >

(

const uint32_t &

from

)

pset1< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pset1< Packet4us >

(

const uint16_t &

from

)

pset1< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pset1< Packet8bf >

(

const bfloat16 &

from

)

pset1< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pset1< Packet8bf >

(

const bfloat16 &

from

)

pset1< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pset1< Packet8c >

(

const int8_t &

from

)

pset1< Packet8cf >()

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pset1< Packet8cf >

(

const std::complex< float > &

from

)

pset1< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pset1< Packet8d >

(

const double &

from

)

pset1< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pset1< Packet8f >

(

const float &

from

)

pset1< Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pset1< Packet8h >

(

const Eigen::half &

from

)

pset1< Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::pset1< Packet8i >

(

const int &

from

)

pset1< Packet8s >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pset1< Packet8s >

(

const int16_t &

from

)

pset1< Packet8s >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pset1< Packet8s >

(

const short int &

from

)

pset1< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pset1< Packet8uc >

(

const uint8_t &

from

)

pset1< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pset1< Packet8us >

(

const uint16_t &

from

)

pset1< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pset1< Packet8us >

(

const unsigned short int &

from

)

pset1< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pset1< PacketXf >

(

const float &

from

)

pset1< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pset1< PacketXi >

(

const numext::int32_t &

from

)

pset1_size16()

template<typename Packet >

EIGEN_STRONG_INLINE Packet Eigen::internal::pset1_size16

(

const __UNPACK_TYPE__(Packet)&

from

)

pset1_size4()

template<typename Packet >

EIGEN_STRONG_INLINE Packet Eigen::internal::pset1_size4

(

const __UNPACK_TYPE__(Packet)&

from

)

pset1_size8()

template<typename Packet >

EIGEN_STRONG_INLINE Packet Eigen::internal::pset1_size8

(

const __UNPACK_TYPE__(Packet)&

from

)

pset1frombits()

template<typename Packet , typename BitsType >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pset1frombits ( BitsType  a )

inline

pset1frombits< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pset1frombits< Packet16f >

(

unsigned int

from

)

pset1frombits< Packet2d >()

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pset1frombits< Packet2d >

(

uint64_t

from

)

pset1frombits< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pset1frombits< Packet2f >

(

unsigned int

from

)

pset1frombits< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pset1frombits< Packet4d >

(

uint64_t

from

)

pset1frombits< Packet4f >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pset1frombits< Packet4f >

(

unsigned int

from

)

pset1frombits< Packet4f >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pset1frombits< Packet4f >

(

unsigned int

from

)

pset1frombits< Packet4f >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pset1frombits< Packet4f >

(

unsigned int

from

)

pset1frombits< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pset1frombits< Packet8d >

(

const numext::uint64_t

from

)

pset1frombits< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pset1frombits< Packet8f >

(

unsigned int

from

)

pset1frombits< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pset1frombits< PacketXf >

(

numext::uint32_t

from

)

psin()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::psin

(

const Packet &

a

)

psin< Packet16f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f Eigen::internal::psin< Packet16f >

(

const Packet16f &

_x

)

psin< Packet2f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f Eigen::internal::psin< Packet2f >

(

const Packet2f &

x

)

psin< Packet4f >() [1/4]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::psin< Packet4f >

(

const Packet4f &

_x

)

psin< Packet4f >() [2/4]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::psin< Packet4f >

(

const Packet4f &

_x

)

psin< Packet4f >() [3/4]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::psin< Packet4f >

(

const Packet4f &

x

)

psin< Packet4f >() [4/4]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::psin< Packet4f >

(

const Packet4f &

x

)

psin< Packet8bf >()

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::psin< Packet8bf >

(

const Packet8bf &

a

)

psin< Packet8f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f Eigen::internal::psin< Packet8f >

(

const Packet8f &

_x

)

psin< PacketXf >()

template<>

EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf Eigen::internal::psin< PacketXf >

(

const PacketXf &

x

)

psin_float()

template<typename Packet >

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::psin_float

(

const Packet &

x

)

psincos_float()

template<bool ComputeSine, typename Packet >

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::psincos_float

(

const Packet &

_x

)

psincos_inner_msa_float()

template<bool sine>

Packet4f Eigen::internal::psincos_inner_msa_float

(

const Packet4f &

_x

)

psinh()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::psinh

(

const Packet &

a

)

psqrt() [1/12]

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::psqrt

(

const Packet &

a

)

psqrt() [2/12]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::psqrt

(

const Packet16uc &

a

)

Computes the integer square root

Remarks

The calculation is performed using an algorithm which iterates through each binary digit of the result and tests whether setting that digit to 1 would cause the square of the value to be greater than the argument value. The algorithm is described in detail here: http://ww1.microchip.com/downloads/en/AppNotes/91040a.pdf .

psqrt() [3/12]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::psqrt

(

const Packet2d &

a

)

psqrt() [4/12]

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::psqrt

(

const Packet2f &

a

)

psqrt() [5/12]

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::psqrt

(

const Packet2ui &

a

)

Computes the integer square root

Remarks

The calculation is performed using an algorithm which iterates through each binary digit of the result and tests whether setting that digit to 1 would cause the square of the value to be greater than the argument value. The algorithm is described in detail here: http://ww1.microchip.com/downloads/en/AppNotes/91040a.pdf .

psqrt() [6/12]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::psqrt

(

const Packet4f &

a

)

psqrt() [7/12]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::psqrt

(

const Packet4f &

a

)

psqrt() [8/12]

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::psqrt

(

const Packet4uc &

a

)

Computes the integer square root

Remarks

The calculation is performed using an algorithm which iterates through each binary digit of the result and tests whether setting that digit to 1 would cause the square of the value to be greater than the argument value. The algorithm is described in detail here: http://ww1.microchip.com/downloads/en/AppNotes/91040a.pdf .

psqrt() [9/12]

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::psqrt

(

const Packet4ui &

a

)

Computes the integer square root

Remarks

The calculation is performed using an algorithm which iterates through each binary digit of the result and tests whether setting that digit to 1 would cause the square of the value to be greater than the argument value. The algorithm is described in detail here: http://ww1.microchip.com/downloads/en/AppNotes/91040a.pdf .

psqrt() [10/12]

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::psqrt

(

const Packet4us &

a

)

Computes the integer square root

Remarks

The calculation is performed using an algorithm which iterates through each binary digit of the result and tests whether setting that digit to 1 would cause the square of the value to be greater than the argument value. The algorithm is described in detail here: http://ww1.microchip.com/downloads/en/AppNotes/91040a.pdf .

psqrt() [11/12]

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::psqrt

(

const Packet8uc &

a

)

Computes the integer square root

Remarks

The calculation is performed using an algorithm which iterates through each binary digit of the result and tests whether setting that digit to 1 would cause the square of the value to be greater than the argument value. The algorithm is described in detail here: http://ww1.microchip.com/downloads/en/AppNotes/91040a.pdf .

psqrt() [12/12]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::psqrt

(

const Packet8us &

a

)

Computes the integer square root

Remarks

The calculation is performed using an algorithm which iterates through each binary digit of the result and tests whether setting that digit to 1 would cause the square of the value to be greater than the argument value. The algorithm is described in detail here: http://ww1.microchip.com/downloads/en/AppNotes/91040a.pdf .

psqrt< Packet16b >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16b Eigen::internal::psqrt< Packet16b >

(

const Packet16b &

x

)

psqrt< Packet1cd >()

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::psqrt< Packet1cd >

(

const Packet1cd &

a

)

psqrt< Packet1cf >()

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::psqrt< Packet1cf >

(

const Packet1cf &

a

)

psqrt< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::psqrt< Packet2cd >

(

const Packet2cd &

a

)

psqrt< Packet2cf >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::psqrt< Packet2cf >

(

const Packet2cf &

a

)

psqrt< Packet2cf >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::psqrt< Packet2cf >

(

const Packet2cf &

a

)

psqrt< Packet2cf >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::psqrt< Packet2cf >

(

const Packet2cf &

a

)

psqrt< Packet2d >() [1/2]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d Eigen::internal::psqrt< Packet2d >

(

const Packet2d &

x

)

psqrt< Packet2d >() [2/2]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d Eigen::internal::psqrt< Packet2d >

(

const Packet2d &

x

)

psqrt< Packet4cd >()

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::psqrt< Packet4cd >

(

const Packet4cd &

a

)

psqrt< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::psqrt< Packet4cf >

(

const Packet4cf &

a

)

psqrt< Packet4d >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d Eigen::internal::psqrt< Packet4d >

(

const Packet4d &

_x

)

psqrt< Packet4f >() [1/2]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::psqrt< Packet4f >

(

const Packet4f &

x

)

psqrt< Packet4f >() [2/2]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::psqrt< Packet4f >

(

const Packet4f &

x

)

psqrt< Packet8bf >()

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::psqrt< Packet8bf >

(

const Packet8bf &

a

)

psqrt< Packet8cf >()

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::psqrt< Packet8cf >

(

const Packet8cf &

a

)

psqrt< Packet8f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f Eigen::internal::psqrt< Packet8f >

(

const Packet8f &

_x

)

psqrt_complex()

template<typename Packet >

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::psqrt_complex

(

const Packet &

a

)

pstore()

template<typename Scalar , typename Packet >

EIGEN_DEVICE_FUNC void Eigen::internal::pstore ( Scalar *  to, const Packet &  from  )

inline

pstore1()

template<typename Packet >

void Eigen::internal::pstore1 ( typename unpacket_traits< Packet >::type *  to, const typename unpacket_traits< Packet >::type &  a  )

inline

pstore1< Packet16f >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet16f >	(	float *	to,
		const float &	a
	)

pstore1< Packet16i >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet16i >	(	int *	to,
		const int &	a
	)

pstore1< Packet2d >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet2d >	(	double *	to,
		const double &	a
	)

pstore1< Packet4d >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet4d >	(	double *	to,
		const double &	a
	)

pstore1< Packet4f >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet4f >	(	float *	to,
		const float &	a
	)

pstore1< Packet8d >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet8d >	(	double *	to,
		const double &	a
	)

pstore1< Packet8f >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet8f >	(	float *	to,
		const float &	a
	)

pstore1< Packet8i >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet8i >	(	int *	to,
		const int &	a
	)

pstore< bfloat16 >() [1/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< bfloat16 >	(	bfloat16 *	to,
		const Packet16bf &	from
	)

pstore< bfloat16 >() [2/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< bfloat16 >	(	bfloat16 *	to,
		const Packet4bf &	from
	)

pstore< bfloat16 >() [3/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< bfloat16 >	(	bfloat16 *	to,
		const Packet8bf &	from
	)

pstore< bfloat16 >() [4/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< bfloat16 >	(	bfloat16 *	to,
		const Packet8bf &	from
	)

pstore< bool >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< bool >	(	bool *	to,
		const Packet16b &	from
	)

pstore< double >() [1/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< double >	(	double *	to,
		const Packet2d &	from
	)

pstore< double >() [2/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< double >	(	double *	to,
		const Packet2d &	from
	)

pstore< double >() [3/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< double >	(	double *	to,
		const Packet2d &	from
	)

pstore< double >() [4/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< double >	(	double *	to,
		const Packet4d &	from
	)

pstore< double >() [5/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< double >	(	double *	to,
		const Packet8d &	from
	)

pstore< Eigen::half >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< Eigen::half >	(	Eigen::half *	to,
		const Packet8h &	from
	)

pstore< float >() [1/9]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< float >	(	float *	to,
		const Packet16f &	from
	)

pstore< float >() [2/9]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< float >	(	float *	to,
		const Packet2f &	from
	)

pstore< float >() [3/9]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< float >	(	float *	to,
		const Packet4f &	from
	)

pstore< float >() [4/9]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< float >	(	float *	to,
		const Packet4f &	from
	)

pstore< float >() [5/9]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< float >	(	float *	to,
		const Packet4f &	from
	)

pstore< float >() [6/9]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< float >	(	float *	to,
		const Packet4f &	from
	)

pstore< float >() [7/9]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< float >	(	float *	to,
		const Packet4f &	from
	)

pstore< float >() [8/9]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< float >	(	float *	to,
		const Packet8f &	from
	)

pstore< float >() [9/9]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< float >	(	float *	to,
		const PacketXf &	from
	)

pstore< half >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< half >	(	Eigen::half *	to,
		const Packet16h &	from
	)

pstore< int >() [1/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int >	(	int *	to,
		const Packet16i &	from
	)

pstore< int >() [2/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int >	(	int *	to,
		const Packet4i &	from
	)

pstore< int >() [3/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int >	(	int *	to,
		const Packet4i &	from
	)

pstore< int >() [4/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int >	(	int *	to,
		const Packet4i &	from
	)

pstore< int >() [5/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int >	(	int *	to,
		const Packet8i &	from
	)

pstore< int16_t >() [1/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int16_t >	(	int16_t *	to,
		const Packet4s &	from
	)

pstore< int16_t >() [2/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int16_t >	(	int16_t *	to,
		const Packet8s &	from
	)

pstore< int32_t >() [1/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int32_t >	(	int32_t *	to,
		const Packet2i &	from
	)

pstore< int32_t >() [2/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int32_t >	(	int32_t *	to,
		const Packet4i &	from
	)

pstore< int32_t >() [3/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int32_t >	(	int32_t *	to,
		const Packet4i &	from
	)

pstore< int64_t >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int64_t >	(	int64_t *	to,
		const Packet2l &	from
	)

pstore< int8_t >() [1/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int8_t >	(	int8_t *	to,
		const Packet16c &	from
	)

pstore< int8_t >() [2/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int8_t >	(	int8_t *	to,
		const Packet4c &	from
	)

pstore< int8_t >() [3/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int8_t >	(	int8_t *	to,
		const Packet8c &	from
	)

pstore< numext::int32_t >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< numext::int32_t >	(	numext::int32_t *	to,
		const PacketXi &	from
	)

pstore< short int >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< short int >	(	short int *	to,
		const Packet8s &	from
	)

pstore< signed char >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< signed char >	(	signed char *	to,
		const Packet16c &	from
	)

pstore< std::complex< double > >() [1/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< double > >	(	std::complex< double > *	to,
		const Packet1cd &	from
	)

pstore< std::complex< double > >() [2/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< double > >	(	std::complex< double > *	to,
		const Packet1cd &	from
	)

pstore< std::complex< double > >() [3/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< double > >	(	std::complex< double > *	to,
		const Packet1cd &	from
	)

pstore< std::complex< double > >() [4/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< double > >	(	std::complex< double > *	to,
		const Packet2cd &	from
	)

pstore< std::complex< double > >() [5/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< double > >	(	std::complex< double > *	to,
		const Packet4cd &	from
	)

pstore< std::complex< float > >() [1/8]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< float > >	(	std::complex< float > *	to,
		const Packet1cf &	from
	)

pstore< std::complex< float > >() [2/8]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

pstore< std::complex< float > >() [3/8]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

pstore< std::complex< float > >() [4/8]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

pstore< std::complex< float > >() [5/8]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

pstore< std::complex< float > >() [6/8]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

pstore< std::complex< float > >() [7/8]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< float > >	(	std::complex< float > *	to,
		const Packet4cf &	from
	)

pstore< std::complex< float > >() [8/8]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< float > >	(	std::complex< float > *	to,
		const Packet8cf &	from
	)

pstore< uint16_t >() [1/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< uint16_t >	(	uint16_t *	to,
		const Packet4us &	from
	)

pstore< uint16_t >() [2/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< uint16_t >	(	uint16_t *	to,
		const Packet8us &	from
	)

pstore< uint32_t >() [1/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< uint32_t >	(	uint32_t *	to,
		const Packet2ui &	from
	)

pstore< uint32_t >() [2/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< uint32_t >	(	uint32_t *	to,
		const Packet4ui &	from
	)

pstore< uint64_t >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< uint64_t >	(	uint64_t *	to,
		const Packet2ul &	from
	)

pstore< uint8_t >() [1/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< uint8_t >	(	uint8_t *	to,
		const Packet16uc &	from
	)

pstore< uint8_t >() [2/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< uint8_t >	(	uint8_t *	to,
		const Packet4uc &	from
	)

pstore< uint8_t >() [3/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< uint8_t >	(	uint8_t *	to,
		const Packet8uc &	from
	)

pstore< unsigned char >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< unsigned char >	(	unsigned char *	to,
		const Packet16uc &	from
	)

pstore< unsigned short int >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< unsigned short int >	(	unsigned short int *	to,
		const Packet8us &	from
	)

pstore_common()

template<typename Packet >

EIGEN_STRONG_INLINE void Eigen::internal::pstore_common	(	__UNPACK_TYPE__(Packet) *	to,
		const Packet &	from
	)

pstoret() [1/2]

template<typename scalar , typename packet_type , int Alignment>

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void Eigen::internal::pstoret	(	Eigen::TensorSycl::internal::RangeAccess< cl::sycl::access::mode::read_write, typename unpacket_traits< packet_type >::type >	to,
		const packet_type &	from
	)

pstoret() [2/2]

template<typename Scalar , typename Packet , int Alignment>

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void Eigen::internal::pstoret	(	Scalar *	to,
		const Packet &	from
	)

pstoreu() [1/2]

template<typename Scalar , typename Packet >

EIGEN_DEVICE_FUNC void Eigen::internal::pstoreu ( Scalar *  to, const Packet &  from  )

inline

pstoreu() [2/2]

template<typename Scalar , typename Packet >

EIGEN_DEVICE_FUNC enable_if< unpacket_traits< Packet >::masked_store_available, void >::type Eigen::internal::pstoreu ( Scalar *  to, const Packet &  from, typename unpacket_traits< Packet >::mask_t  umask  )

inline

pstoreu< bfloat16 >() [1/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< bfloat16 >	(	bfloat16 *	to,
		const Packet16bf &	from
	)

pstoreu< bfloat16 >() [2/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< bfloat16 >	(	bfloat16 *	to,
		const Packet4bf &	from
	)

pstoreu< bfloat16 >() [3/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< bfloat16 >	(	bfloat16 *	to,
		const Packet8bf &	from
	)

pstoreu< bfloat16 >() [4/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< bfloat16 >	(	bfloat16 *	to,
		const Packet8bf &	from
	)

pstoreu< bool >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< bool >	(	bool *	to,
		const Packet16b &	from
	)

pstoreu< double >() [1/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< double >	(	double *	to,
		const Packet2d &	from
	)

pstoreu< double >() [2/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< double >	(	double *	to,
		const Packet2d &	from
	)

pstoreu< double >() [3/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< double >	(	double *	to,
		const Packet2d &	from
	)

pstoreu< double >() [4/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< double >	(	double *	to,
		const Packet4d &	from
	)

pstoreu< double >() [5/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< double >	(	double *	to,
		const Packet8d &	from
	)

pstoreu< Eigen::half >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< Eigen::half >	(	Eigen::half *	to,
		const Packet8h &	from
	)

pstoreu< float >() [1/11]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float >	(	float *	to,
		const Packet16f &	from
	)

pstoreu< float >() [2/11]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float >	(	float *	to,
		const Packet16f &	from,
		uint16_t	umask
	)

pstoreu< float >() [3/11]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float >	(	float *	to,
		const Packet2f &	from
	)

pstoreu< float >() [4/11]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float >	(	float *	to,
		const Packet4f &	from
	)

pstoreu< float >() [5/11]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float >	(	float *	to,
		const Packet4f &	from
	)

pstoreu< float >() [6/11]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float >	(	float *	to,
		const Packet4f &	from
	)

pstoreu< float >() [7/11]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float >	(	float *	to,
		const Packet4f &	from
	)

pstoreu< float >() [8/11]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float >	(	float *	to,
		const Packet4f &	from
	)

pstoreu< float >() [9/11]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float >	(	float *	to,
		const Packet8f &	from
	)

pstoreu< float >() [10/11]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float >	(	float *	to,
		const Packet8f &	from,
		uint8_t	umask
	)

pstoreu< float >() [11/11]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float >	(	float *	to,
		const PacketXf &	from
	)

pstoreu< half >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< half >	(	Eigen::half *	to,
		const Packet16h &	from
	)

pstoreu< int >() [1/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int >	(	int *	to,
		const Packet16i &	from
	)

pstoreu< int >() [2/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int >	(	int *	to,
		const Packet4i &	from
	)

pstoreu< int >() [3/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int >	(	int *	to,
		const Packet4i &	from
	)

pstoreu< int >() [4/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int >	(	int *	to,
		const Packet4i &	from
	)

pstoreu< int >() [5/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int >	(	int *	to,
		const Packet8i &	from
	)

pstoreu< int16_t >() [1/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int16_t >	(	int16_t *	to,
		const Packet4s &	from
	)

pstoreu< int16_t >() [2/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int16_t >	(	int16_t *	to,
		const Packet8s &	from
	)

pstoreu< int32_t >() [1/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int32_t >	(	int32_t *	to,
		const Packet2i &	from
	)

pstoreu< int32_t >() [2/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int32_t >	(	int32_t *	to,
		const Packet4i &	from
	)

pstoreu< int32_t >() [3/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int32_t >	(	int32_t *	to,
		const Packet4i &	from
	)

pstoreu< int64_t >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int64_t >	(	int64_t *	to,
		const Packet2l &	from
	)

pstoreu< int8_t >() [1/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int8_t >	(	int8_t *	to,
		const Packet16c &	from
	)

pstoreu< int8_t >() [2/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int8_t >	(	int8_t *	to,
		const Packet4c &	from
	)

pstoreu< int8_t >() [3/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int8_t >	(	int8_t *	to,
		const Packet8c &	from
	)

pstoreu< numext::int32_t >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< numext::int32_t >	(	numext::int32_t *	to,
		const PacketXi &	from
	)

pstoreu< short int >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< short int >	(	short int *	to,
		const Packet8s &	from
	)

pstoreu< signed char >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< signed char >	(	signed char *	to,
		const Packet16c &	from
	)

pstoreu< std::complex< double > >() [1/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< double > >	(	std::complex< double > *	to,
		const Packet1cd &	from
	)

pstoreu< std::complex< double > >() [2/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< double > >	(	std::complex< double > *	to,
		const Packet1cd &	from
	)

pstoreu< std::complex< double > >() [3/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< double > >	(	std::complex< double > *	to,
		const Packet1cd &	from
	)

pstoreu< std::complex< double > >() [4/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< double > >	(	std::complex< double > *	to,
		const Packet2cd &	from
	)

pstoreu< std::complex< double > >() [5/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< double > >	(	std::complex< double > *	to,
		const Packet4cd &	from
	)

pstoreu< std::complex< float > >() [1/8]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< float > >	(	std::complex< float > *	to,
		const Packet1cf &	from
	)

pstoreu< std::complex< float > >() [2/8]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

pstoreu< std::complex< float > >() [3/8]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

pstoreu< std::complex< float > >() [4/8]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

pstoreu< std::complex< float > >() [5/8]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

pstoreu< std::complex< float > >() [6/8]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

pstoreu< std::complex< float > >() [7/8]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< float > >	(	std::complex< float > *	to,
		const Packet4cf &	from
	)

pstoreu< std::complex< float > >() [8/8]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< float > >	(	std::complex< float > *	to,
		const Packet8cf &	from
	)

pstoreu< uint16_t >() [1/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< uint16_t >	(	uint16_t *	to,
		const Packet4us &	from
	)

pstoreu< uint16_t >() [2/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< uint16_t >	(	uint16_t *	to,
		const Packet8us &	from
	)

pstoreu< uint32_t >() [1/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< uint32_t >	(	uint32_t *	to,
		const Packet2ui &	from
	)

pstoreu< uint32_t >() [2/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< uint32_t >	(	uint32_t *	to,
		const Packet4ui &	from
	)

pstoreu< uint64_t >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< uint64_t >	(	uint64_t *	to,
		const Packet2ul &	from
	)

pstoreu< uint8_t >() [1/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< uint8_t >	(	uint8_t *	to,
		const Packet16uc &	from
	)

pstoreu< uint8_t >() [2/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< uint8_t >	(	uint8_t *	to,
		const Packet4uc &	from
	)

pstoreu< uint8_t >() [3/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< uint8_t >	(	uint8_t *	to,
		const Packet8uc &	from
	)

pstoreu< unsigned char >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< unsigned char >	(	unsigned char *	to,
		const Packet16uc &	from
	)

pstoreu< unsigned short int >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< unsigned short int >	(	unsigned short int *	to,
		const Packet8us &	from
	)

pstoreu_common()

template<typename Packet >

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu_common	(	__UNPACK_TYPE__(Packet) *	to,
		const Packet &	from
	)

psub()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::psub ( const Packet &  a, const Packet &  b  )

inline

psub< Packet16b >()

template<>

EIGEN_STRONG_INLINE Packet16b Eigen::internal::psub< Packet16b >	(	const Packet16b &	a,
		const Packet16b &	b
	)

psub< Packet16bf >()

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::psub< Packet16bf >	(	const Packet16bf &	a,
		const Packet16bf &	b
	)

psub< Packet16c >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::psub< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

psub< Packet16c >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::psub< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

psub< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::psub< Packet16f >	(	const Packet16f &	a,
		const Packet16f &	b
	)

psub< Packet16h >()

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::psub< Packet16h >	(	const Packet16h &	a,
		const Packet16h &	b
	)

psub< Packet16i >()

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::psub< Packet16i >	(	const Packet16i &	a,
		const Packet16i &	b
	)

psub< Packet16uc >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::psub< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

psub< Packet16uc >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::psub< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

psub< Packet1cd >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::psub< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

psub< Packet1cd >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::psub< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

psub< Packet1cd >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::psub< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

psub< Packet1cf >()

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::psub< Packet1cf >	(	const Packet1cf &	a,
		const Packet1cf &	b
	)

psub< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::psub< Packet2cd >	(	const Packet2cd &	a,
		const Packet2cd &	b
	)

psub< Packet2cf >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::psub< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

psub< Packet2cf >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::psub< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

psub< Packet2cf >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::psub< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

psub< Packet2cf >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::psub< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

psub< Packet2cf >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::psub< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

psub< Packet2d >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::psub< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

psub< Packet2d >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::psub< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

psub< Packet2d >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::psub< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

psub< Packet2f >()

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::psub< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

psub< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::psub< Packet2i >	(	const Packet2i &	a,
		const Packet2i &	b
	)

psub< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::psub< Packet2l >	(	const Packet2l &	a,
		const Packet2l &	b
	)

psub< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::psub< Packet2ui >	(	const Packet2ui &	a,
		const Packet2ui &	b
	)

psub< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::psub< Packet2ul >	(	const Packet2ul &	a,
		const Packet2ul &	b
	)

psub< Packet4bf >()

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::psub< Packet4bf >	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

psub< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::psub< Packet4c >	(	const Packet4c &	a,
		const Packet4c &	b
	)

psub< Packet4cd >()

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::psub< Packet4cd >	(	const Packet4cd &	a,
		const Packet4cd &	b
	)

psub< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::psub< Packet4cf >	(	const Packet4cf &	a,
		const Packet4cf &	b
	)

psub< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::psub< Packet4d >	(	const Packet4d &	a,
		const Packet4d &	b
	)

psub< Packet4f >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::psub< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

psub< Packet4f >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::psub< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

psub< Packet4f >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::psub< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

psub< Packet4f >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::psub< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

psub< Packet4f >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::psub< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

psub< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::psub< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

psub< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::psub< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

psub< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::psub< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

psub< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::psub< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

psub< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::psub< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

psub< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::psub< Packet4s >	(	const Packet4s &	a,
		const Packet4s &	b
	)

psub< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::psub< Packet4uc >	(	const Packet4uc &	a,
		const Packet4uc &	b
	)

psub< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::psub< Packet4ui >	(	const Packet4ui &	a,
		const Packet4ui &	b
	)

psub< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::psub< Packet4us >	(	const Packet4us &	a,
		const Packet4us &	b
	)

psub< Packet8bf >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::psub< Packet8bf >	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

psub< Packet8bf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::psub< Packet8bf >	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

psub< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::psub< Packet8c >	(	const Packet8c &	a,
		const Packet8c &	b
	)

psub< Packet8cf >()

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::psub< Packet8cf >	(	const Packet8cf &	a,
		const Packet8cf &	b
	)

psub< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::psub< Packet8d >	(	const Packet8d &	a,
		const Packet8d &	b
	)

psub< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::psub< Packet8f >	(	const Packet8f &	a,
		const Packet8f &	b
	)

psub< Packet8h >()

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::psub< Packet8h >	(	const Packet8h &	a,
		const Packet8h &	b
	)

psub< Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::psub< Packet8i >	(	const Packet8i &	a,
		const Packet8i &	b
	)

psub< Packet8s >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::psub< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

psub< Packet8s >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::psub< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

psub< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::psub< Packet8uc >	(	const Packet8uc &	a,
		const Packet8uc &	b
	)

psub< Packet8us >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::psub< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

psub< Packet8us >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::psub< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

psub< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::psub< PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

psub< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::psub< PacketXi >	(	const PacketXi &	a,
		const PacketXi &	b
	)

ptan()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::ptan

(

const Packet &

a

)

ptanh()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::ptanh

(

const Packet &

a

)

ptanh< Packet16f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f Eigen::internal::ptanh< Packet16f >

(

const Packet16f &

_x

)

ptanh< Packet2f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f Eigen::internal::ptanh< Packet2f >

(

const Packet2f &

x

)

ptanh< Packet4f >() [1/5]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::ptanh< Packet4f >

(

const Packet4f &

_x

)

ptanh< Packet4f >() [2/5]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::ptanh< Packet4f >

(

const Packet4f &

x

)

ptanh< Packet4f >() [3/5]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::ptanh< Packet4f >

(

const Packet4f &

x

)

ptanh< Packet4f >() [4/5]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::ptanh< Packet4f >

(

const Packet4f &

x

)

ptanh< Packet4f >() [5/5]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::ptanh< Packet4f >

(

const Packet4f &

x

)

ptanh< Packet8f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f Eigen::internal::ptanh< Packet8f >

(

const Packet8f &

_x

)

ptanh< PacketXf >()

template<>

EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf Eigen::internal::ptanh< PacketXf >

(

const PacketXf &

x

)

ptranpose_common()

template<typename T >

EIGEN_DEVICE_FUNC void Eigen::internal::ptranpose_common ( PacketBlock< T, 4 > &  kernel )

inline

ptranspose() [1/57]

template<typename Packet >

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet, 1 > &  )

inline

ptranspose() [2/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet16b, 16 > &  kernel )

inline

ptranspose() [3/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet16b, 4 > &  kernel )

inline

ptranspose() [4/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet16bf, 16 > &

kernel

)

ptranspose() [5/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet16bf, 4 > &

kernel

)

ptranspose() [6/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet16c, 16 > &  kernel )

inline

ptranspose() [7/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet16c, 4 > &  kernel )

inline

ptranspose() [8/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet16c, 8 > &

kernel

)

ptranspose() [9/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet16f, 16 > &  kernel )

inline

ptranspose() [10/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet16f, 4 > &  kernel )

inline

ptranspose() [11/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet16h, 16 > &

kernel

)

ptranspose() [12/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet16h, 4 > &

kernel

)

ptranspose() [13/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet16h, 8 > &

kernel

)

ptranspose() [14/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet16uc, 16 > &  kernel )

inline

ptranspose() [15/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet16uc, 4 > &  kernel )

inline

ptranspose() [16/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet16uc, 8 > &

kernel

)

ptranspose() [17/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet1cd, 2 > &

kernel

)

ptranspose() [18/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet1cf, 1 > &  )

inline

ptranspose() [19/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet2cd, 2 > &  kernel )

inline

ptranspose() [20/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet2cf, 2 > &  kernel )

inline

ptranspose() [21/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet2d, 2 > &  kernel )

inline

ptranspose() [22/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet2f, 2 > &

kernel

)

ptranspose() [23/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet2i, 2 > &

kernel

)

ptranspose() [24/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet2l, 2 > &

kernel

)

ptranspose() [25/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet2ui, 2 > &

kernel

)

ptranspose() [26/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet2ul, 2 > &

kernel

)

ptranspose() [27/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet4bf, 4 > &

kernel

)

ptranspose() [28/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet4c, 4 > &

kernel

)

ptranspose() [29/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet4cd, 4 > &  kernel )

inline

ptranspose() [30/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet4cf, 4 > &  kernel )

inline

ptranspose() [31/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet4d, 4 > &  kernel )

inline

ptranspose() [32/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet4f, 4 > &  kernel )

inline

ptranspose() [33/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet4i, 4 > &  kernel )

inline

ptranspose() [34/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet4s, 4 > &

kernel

)

ptranspose() [35/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet4uc, 4 > &

kernel

)

ptranspose() [36/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet4ui, 4 > &

kernel

)

ptranspose() [37/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet4us, 4 > &

kernel

)

ptranspose() [38/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8bf, 4 > &  kernel )

inline

ptranspose() [39/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8bf, 8 > &  kernel )

inline

ptranspose() [40/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet8c, 4 > &

kernel

)

ptranspose() [41/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet8c, 8 > &

kernel

)

ptranspose() [42/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet8cf, 4 > &  kernel )

inline

ptranspose() [43/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet8cf, 8 > &  kernel )

inline

ptranspose() [44/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet8d, 4 > &  kernel )

inline

ptranspose() [45/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet8d, 8 > &  kernel )

inline

ptranspose() [46/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet8f, 4 > &  kernel )

inline

ptranspose() [47/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet8f, 8 > &  kernel )

inline

ptranspose() [48/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet8h, 4 > &

kernel

)

ptranspose() [49/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet8h, 8 > &

kernel

)

ptranspose() [50/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8s, 4 > &  kernel )

inline

ptranspose() [51/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8s, 8 > &  kernel )

inline

ptranspose() [52/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet8uc, 4 > &

kernel

)

ptranspose() [53/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet8uc, 8 > &

kernel

)

ptranspose() [54/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8us, 4 > &  kernel )

inline

ptranspose() [55/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8us, 8 > &  kernel )

inline

ptranspose() [56/57]

template<int N>

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< PacketXf, N > &  kernel )

inline

ptranspose() [57/57]

template<int N>

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< PacketXi, N > &  kernel )

inline

ptrue() [1/5]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::ptrue ( const Packet &  a )

inline

ptrue() [2/5]

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::ptrue

(

const Packet16bf &

a

)

ptrue() [3/5]

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::ptrue

(

const Packet16h &

a

)

ptrue() [4/5]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::ptrue

(

const Packet8bf &

a

)

ptrue() [5/5]

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::ptrue

(

const Packet8h &

a

)

ptrue< Packet16b >()

template<>

EIGEN_STRONG_INLINE Packet16b Eigen::internal::ptrue< Packet16b >

(

const Packet16b &

a

)

ptrue< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::ptrue< Packet16f >

(

const Packet16f &

a

)

ptrue< Packet16i >()

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::ptrue< Packet16i >

(

const Packet16i &

)

ptrue< Packet1cd >()

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::ptrue< Packet1cd >

(

const Packet1cd &

a

)

ptrue< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::ptrue< Packet2cd >

(

const Packet2cd &

a

)

ptrue< Packet2cf >()

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ptrue< Packet2cf >

(

const Packet2cf &

a

)

ptrue< Packet2d >()

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::ptrue< Packet2d >

(

const Packet2d &

a

)

ptrue< Packet4cd >()

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::ptrue< Packet4cd >

(

const Packet4cd &

a

)

ptrue< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::ptrue< Packet4cf >

(

const Packet4cf &

a

)

ptrue< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::ptrue< Packet4d >

(

const Packet4d &

a

)

ptrue< Packet4f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ptrue< Packet4f >

(

const Packet4f &

a

)

ptrue< Packet4i >()

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ptrue< Packet4i >

(

const Packet4i &

a

)

ptrue< Packet8cf >()

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::ptrue< Packet8cf >

(

const Packet8cf &

a

)

ptrue< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::ptrue< Packet8d >

(

const Packet8d &

a

)

ptrue< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::ptrue< Packet8f >

(

const Packet8f &

a

)

ptrue< Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::ptrue< Packet8i >

(

const Packet8i &

a

)

ptrue< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::ptrue< PacketXf >

(

const PacketXf &

)

ptrue< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::ptrue< PacketXi >

(

const PacketXi &

)

punpackp()

EIGEN_STRONG_INLINE void Eigen::internal::punpackp

(

Packet4f *

vecs

)

putMarketHeader()

template<typename Scalar >

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

inline

PutMatrixElt() [1/2]

template<typename Scalar , typename StorageIndex >

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

inline

PutMatrixElt() [2/2]

template<typename Scalar , typename StorageIndex >

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

inline

putVectorElt() [1/2]

template<typename Scalar >

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

inline

putVectorElt() [2/2]

template<typename Scalar >

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

inline

pxor() [1/6]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pxor ( const Packet &  a, const Packet &  b  )

inline

pxor() [2/6]

template<>

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pxor	(	const Packet16bf &	a,
		const Packet16bf &	b
	)

pxor() [3/6]

template<>

EIGEN_STRONG_INLINE Packet16h Eigen::internal::pxor	(	const Packet16h &	a,
		const Packet16h &	b
	)

pxor() [4/6]

template<>

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pxor	(	const Packet4bf &	a,
		const Packet4bf &	b
	)

pxor() [5/6]

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pxor	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pxor() [6/6]

template<>

EIGEN_STRONG_INLINE Packet8h Eigen::internal::pxor	(	const Packet8h &	a,
		const Packet8h &	b
	)

pxor< Packet16b >()

template<>

EIGEN_STRONG_INLINE Packet16b Eigen::internal::pxor< Packet16b >	(	const Packet16b &	a,
		const Packet16b &	b
	)

pxor< Packet16c >()

template<>

EIGEN_STRONG_INLINE Packet16c Eigen::internal::pxor< Packet16c >	(	const Packet16c &	a,
		const Packet16c &	b
	)

pxor< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pxor< Packet16f >	(	const Packet16f &	a,
		const Packet16f &	b
	)

pxor< Packet16i >()

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::pxor< Packet16i >	(	const Packet16i &	a,
		const Packet16i &	b
	)

pxor< Packet16uc >()

template<>

EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pxor< Packet16uc >	(	const Packet16uc &	a,
		const Packet16uc &	b
	)

pxor< Packet1cd >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pxor< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

pxor< Packet1cd >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pxor< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

pxor< Packet1cd >() [3/3]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pxor< Packet1cd >	(	const Packet1cd &	a,
		const Packet1cd &	b
	)

pxor< Packet1cf >()

template<>

EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pxor< Packet1cf >	(	const Packet1cf &	a,
		const Packet1cf &	b
	)

pxor< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pxor< Packet2cd >	(	const Packet2cd &	a,
		const Packet2cd &	b
	)

pxor< Packet2cf >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pxor< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pxor< Packet2cf >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pxor< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pxor< Packet2cf >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pxor< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pxor< Packet2cf >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pxor< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pxor< Packet2cf >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pxor< Packet2cf >	(	const Packet2cf &	a,
		const Packet2cf &	b
	)

pxor< Packet2d >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pxor< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pxor< Packet2d >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pxor< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pxor< Packet2d >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pxor< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pxor< Packet2d >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pxor< Packet2d >	(	const Packet2d &	a,
		const Packet2d &	b
	)

pxor< Packet2f >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pxor< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

pxor< Packet2f >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet2f Eigen::internal::pxor< Packet2f >	(	const Packet2f &	a,
		const Packet2f &	b
	)

pxor< Packet2i >()

template<>

EIGEN_STRONG_INLINE Packet2i Eigen::internal::pxor< Packet2i >	(	const Packet2i &	a,
		const Packet2i &	b
	)

pxor< Packet2l >()

template<>

EIGEN_STRONG_INLINE Packet2l Eigen::internal::pxor< Packet2l >	(	const Packet2l &	a,
		const Packet2l &	b
	)

pxor< Packet2ui >()

template<>

EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pxor< Packet2ui >	(	const Packet2ui &	a,
		const Packet2ui &	b
	)

pxor< Packet2ul >()

template<>

EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pxor< Packet2ul >	(	const Packet2ul &	a,
		const Packet2ul &	b
	)

pxor< Packet4c >()

template<>

EIGEN_STRONG_INLINE Packet4c Eigen::internal::pxor< Packet4c >	(	const Packet4c &	a,
		const Packet4c &	b
	)

pxor< Packet4cd >()

template<>

EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pxor< Packet4cd >	(	const Packet4cd &	a,
		const Packet4cd &	b
	)

pxor< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pxor< Packet4cf >	(	const Packet4cf &	a,
		const Packet4cf &	b
	)

pxor< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pxor< Packet4d >	(	const Packet4d &	a,
		const Packet4d &	b
	)

pxor< Packet4f >() [1/7]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pxor< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pxor< Packet4f >() [2/7]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pxor< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pxor< Packet4f >() [3/7]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pxor< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pxor< Packet4f >() [4/7]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pxor< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pxor< Packet4f >() [5/7]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pxor< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pxor< Packet4f >() [6/7]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pxor< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pxor< Packet4f >() [7/7]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pxor< Packet4f >	(	const Packet4f &	a,
		const Packet4f &	b
	)

pxor< Packet4i >() [1/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pxor< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pxor< Packet4i >() [2/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pxor< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pxor< Packet4i >() [3/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pxor< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pxor< Packet4i >() [4/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pxor< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pxor< Packet4i >() [5/5]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pxor< Packet4i >	(	const Packet4i &	a,
		const Packet4i &	b
	)

pxor< Packet4s >()

template<>

EIGEN_STRONG_INLINE Packet4s Eigen::internal::pxor< Packet4s >	(	const Packet4s &	a,
		const Packet4s &	b
	)

pxor< Packet4uc >()

template<>

EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pxor< Packet4uc >	(	const Packet4uc &	a,
		const Packet4uc &	b
	)

pxor< Packet4ui >()

template<>

EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pxor< Packet4ui >	(	const Packet4ui &	a,
		const Packet4ui &	b
	)

pxor< Packet4us >()

template<>

EIGEN_STRONG_INLINE Packet4us Eigen::internal::pxor< Packet4us >	(	const Packet4us &	a,
		const Packet4us &	b
	)

pxor< Packet8bf >()

template<>

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pxor< Packet8bf >	(	const Packet8bf &	a,
		const Packet8bf &	b
	)

pxor< Packet8c >()

template<>

EIGEN_STRONG_INLINE Packet8c Eigen::internal::pxor< Packet8c >	(	const Packet8c &	a,
		const Packet8c &	b
	)

pxor< Packet8cf >()

template<>

EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pxor< Packet8cf >	(	const Packet8cf &	a,
		const Packet8cf &	b
	)

pxor< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pxor< Packet8d >	(	const Packet8d &	a,
		const Packet8d &	b
	)

pxor< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pxor< Packet8f >	(	const Packet8f &	a,
		const Packet8f &	b
	)

pxor< Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::pxor< Packet8i >	(	const Packet8i &	a,
		const Packet8i &	b
	)

pxor< Packet8s >()

template<>

EIGEN_STRONG_INLINE Packet8s Eigen::internal::pxor< Packet8s >	(	const Packet8s &	a,
		const Packet8s &	b
	)

pxor< Packet8uc >()

template<>

EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pxor< Packet8uc >	(	const Packet8uc &	a,
		const Packet8uc &	b
	)

pxor< Packet8us >()

template<>

EIGEN_STRONG_INLINE Packet8us Eigen::internal::pxor< Packet8us >	(	const Packet8us &	a,
		const Packet8us &	b
	)

pxor< PacketXf >()

template<>

EIGEN_STRONG_INLINE PacketXf Eigen::internal::pxor< PacketXf >	(	const PacketXf &	a,
		const PacketXf &	b
	)

pxor< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pxor< PacketXi >	(	const PacketXi &	a,
		const PacketXi &	b
	)

pzero() [1/10]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pzero ( const Packet &  a )

inline

pzero() [2/10]

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pzero

(

const Packet16f &

)

pzero() [3/10]

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::pzero

(

const Packet16i &

)

pzero() [4/10]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pzero

(

const Packet2d &

)

pzero() [5/10]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pzero

(

const Packet4d &

)

pzero() [6/10]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pzero

(

const Packet4f &

)

pzero() [7/10]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pzero

(

const Packet4i &

)

pzero() [8/10]

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pzero

(

const Packet8d &

)

pzero() [9/10]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pzero

(

const Packet8f &

)

pzero() [10/10]

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::pzero

(

const Packet8i &

)

pzero< PacketXi >()

template<>

EIGEN_STRONG_INLINE PacketXi Eigen::internal::pzero< PacketXi >

(

const PacketXi &

)

pzeta()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pzeta	(	const Packet &	x,
		const Packet &	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
	)

queryCacheSizes()

void Eigen::internal::queryCacheSizes ( int &  l1, int &  l2, int &  l3  )

inline

queryL1CacheSize()

int Eigen::internal::queryL1CacheSize ( )

inline

queryTopLevelCacheSize()

int Eigen::internal::queryTopLevelCacheSize ( )

inline

QuickSplit()

template<typename VectorV , typename VectorI >

Index Eigen::internal::QuickSplit	(	VectorV &	row,
		VectorI &	ind,
		Index	ncut
	)

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
	)

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
	)

RandomToTypeNormal()

template<typename T >

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

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

template<>

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

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

template<>

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

RandomToTypeUniform()

template<typename T >

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

RandomToTypeUniform< double >()

template<>

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

RandomToTypeUniform< Eigen::bfloat16 >()

template<>

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

RandomToTypeUniform< Eigen::half >()

template<>

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

RandomToTypeUniform< float >()

template<>

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

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

template<>

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

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

template<>

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

rcond_estimate_helper()

template<typename Decomposition >

Decomposition::RealScalar Eigen::internal::rcond_estimate_helper	(	typename Decomposition::RealScalar	matrix_norm,
		const Decomposition &	dec
	)

Reciprocal condition number estimator.

Computing a decomposition of a dense matrix takes O(n^3) operations, while this method estimates the condition number quickly and reliably in O(n^2) operations.

Returns

an estimate of the reciprocal condition number (1 / (||matrix||_1 * ||inv(matrix)||_1)) of matrix, given ||matrix||_1 and its decomposition. Supports the following decompositions: FullPivLU, PartialPivLU, LDLT, and LLT.

See also

FullPivLU, PartialPivLU, LDLT, LLT.

rcond_invmatrix_L1_norm_estimate()

template<typename Decomposition >

Decomposition::RealScalar Eigen::internal::rcond_invmatrix_L1_norm_estimate

(

const Decomposition &

dec

)

Returns

an estimate of ||inv(matrix)||_1 given a decomposition of matrix that implements .solve() and .adjoint().solve() methods.

This function implements Algorithms 4.1 and 5.1 from http://www.maths.manchester.ac.uk/~higham/narep/narep135.pdf which also forms the basis for the condition number estimators in LAPACK. Since at most 10 calls to the solve method of dec are performed, the total cost is O(dims^2), as opposed to O(dims^3) needed to compute the inverse matrix explicitly.

The most common usage is in estimating the condition number ||matrix||_1 * ||inv(matrix)||_1. The first term ||matrix||_1 can be computed directly in O(n^2) operations.

Supports the following decompositions: FullPivLU, PartialPivLU, LDLT, and LLT.

See also

FullPivLU, PartialPivLU, LDLT, LLT.

real_2x2_jacobi_svd()

template<typename MatrixType , typename RealScalar , typename Index >

void Eigen::internal::real_2x2_jacobi_svd	(	const MatrixType &	matrix,
		Index	p,
		Index	q,
		JacobiRotation< RealScalar > *	j_left,
		JacobiRotation< RealScalar > *	j_right
	)

ReducePacket()

template<typename Self >

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

protected

ReduceScalar()

template<typename Self >

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

protected

repeat()

template<int n, typename t >

constexpr array< t, n > Eigen::internal::repeat ( t  v )

constexpr

resize_if_allowed() [1/2]

template<typename DstXprType , typename SrcXprType , typename Functor >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::resize_if_allowed	(	DstXprType &	dst,
		const SrcXprType &	src,
		const Functor &
	)

resize_if_allowed() [2/2]

template<typename DstXprType , typename SrcXprType , typename T1 , typename T2 >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::resize_if_allowed	(	DstXprType &	dst,
		const SrcXprType &	src,
		const internal::assign_op< T1, T2 > &
	)

return_ptr()

template<typename T >

const T * Eigen::internal::return_ptr

(

)

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
	)

set_from_triplets()

template<typename InputIterator , typename SparseMatrixType , typename DupFunctor >

void Eigen::internal::set_from_triplets	(	const InputIterator &	begin,
		const InputIterator &	end,
		SparseMatrixType &	mat,
		DupFunctor	dup_func
	)

shuffle1()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::shuffle1	(	const Packet4f &	m,
		int	mask
	)

shuffle2()

template<bool interleave>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::shuffle2	(	const Packet4f &	m,
		const Packet4f &	n,
		int	mask
	)

shuffle2< true >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::shuffle2< true >	(	const Packet4f &	m,
		const Packet4f &	n,
		int	mask
	)

size() [1/2]

template<typename T >

EIGEN_CONSTEXPR Index Eigen::internal::size

(

const T &

x

)

size() [2/2]

template<typename T , std::size_t N>

EIGEN_CONSTEXPR Index Eigen::internal::size

(

const

T(&)[N]

)

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
	)

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
	)

smart_copy()

template<typename T >

EIGEN_DEVICE_FUNC void Eigen::internal::smart_copy	(	const T *	start,
		const T *	end,
		T *	target
	)

smart_memmove()

template<typename T >

void Eigen::internal::smart_memmove	(	const T *	start,
		const T *	end,
		T *	target
	)

smart_move()

template<typename T >

EIGEN_DEVICE_FUNC T * Eigen::internal::smart_move	(	T *	start,
		T *	end,
		T *	target
	)

solve_sparse_through_dense_panels() [1/2]

template<typename Decomposition , typename Rhs , typename Dest >

enable_if< Rhs::ColsAtCompileTime!=1 &&Dest::ColsAtCompileTime!=1 >::type Eigen::internal::solve_sparse_through_dense_panels	(	const Decomposition &	dec,
		const Rhs &	rhs,
		Dest &	dest
	)

solve_sparse_through_dense_panels() [2/2]

template<typename Decomposition , typename Rhs , typename Dest >

enable_if< Rhs::ColsAtCompileTime==1||Dest::ColsAtCompileTime==1 >::type Eigen::internal::solve_sparse_through_dense_panels	(	const Decomposition &	dec,
		const Rhs &	rhs,
		Dest &	dest
	)

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

sparse_selfadjoint_time_dense_product()

template<int Mode, typename SparseLhsType , typename DenseRhsType , typename DenseResType , typename AlphaType >

void Eigen::internal::sparse_selfadjoint_time_dense_product ( const SparseLhsType &  lhs, const DenseRhsType &  rhs, DenseResType &  res, const AlphaType &  alpha  )

inline

sparse_time_dense_product()

template<typename SparseLhsType , typename DenseRhsType , typename DenseResType , typename AlphaType >

void Eigen::internal::sparse_time_dense_product ( const SparseLhsType &  lhs, const DenseRhsType &  rhs, DenseResType &  res, const AlphaType &  alpha  )

inline

sparselu_gemm()

template<typename Scalar >

EIGEN_DONT_INLINE void Eigen::internal::sparselu_gemm	(	Index	m,
		Index	n,
		Index	d,
		const Scalar *	A,
		Index	lda,
		const Scalar *	B,
		Index	ldb,
		Scalar *	C,
		Index	ldc
	)

stable_norm_impl() [1/2]

template<typename MatrixType >

MatrixType::RealScalar Eigen::internal::stable_norm_impl	(	const MatrixType &	mat,
		typename enable_if<!MatrixType::IsVectorAtCompileTime >::type *	= 0
	)

stable_norm_impl() [2/2]

template<typename VectorType >

VectorType::RealScalar Eigen::internal::stable_norm_impl	(	const VectorType &	vec,
		typename enable_if< VectorType::IsVectorAtCompileTime >::type *	= 0
	)

stable_norm_impl_inner_step()

template<typename VectorType , typename RealScalar >

void Eigen::internal::stable_norm_impl_inner_step	(	const VectorType &	vec,
		RealScalar &	ssq,
		RealScalar &	scale,
		RealScalar &	invScale
	)

stable_norm_kernel()

template<typename ExpressionType , typename Scalar >

void Eigen::internal::stable_norm_kernel ( const ExpressionType &  bl, Scalar &  ssq, Scalar &  scale, Scalar &  invScale  )

inline

stem_function_cos()

template<typename Scalar >

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

Cosine (and its derivatives).

stem_function_cosh()

template<typename Scalar >

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

Hyperbolic cosine (and its derivatives).

stem_function_exp()

template<typename Scalar >

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

The exponential function (and its derivatives).

stem_function_sin()

template<typename Scalar >

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

Sine (and its derivatives).

stem_function_sinh()

template<typename Scalar >

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

Hyperbolic sine (and its derivatives).

storeAccumulator()

template<typename DataMapper , typename Index , typename Packet , const Index accCols>

EIGEN_ALWAYS_INLINE void Eigen::internal::storeAccumulator	(	Index	i,
		Index	j,
		const DataMapper &	data,
		const Packet &	alpha,
		__vector_quad *	acc
	)

storeBlock() [1/2]

template<typename Scalar , typename Packet , typename Index >

EIGEN_ALWAYS_INLINE void Eigen::internal::storeBlock	(	Scalar *	to,
		PacketBlock< Packet, 2 > &	block
	)

storeBlock() [2/2]

template<typename Scalar , typename Packet , typename Index >

EIGEN_ALWAYS_INLINE void Eigen::internal::storeBlock	(	Scalar *	to,
		PacketBlock< Packet, 4 > &	block
	)

PanelMode Packing might be called several times before being multiplied by gebp_kernel, this happens because on special occasions it fills part of block with other parts of the matrix. Two variables control how PanelMode should behave: offset and stride. The idea is that those variables represent whatever is going to be the real offset and stride in the future and this is what you should obey. The process is to behave as you would with normal packing but leave the start of each part with the correct offset and the end as well respecting the real stride the block will have. Gebp is aware of both blocks stride and offset and behaves accordingly.

storeComplexAccumulator()

template<typename DataMapper , typename Index , typename Packet , typename Packetc , const Index accColsC, int N>

EIGEN_ALWAYS_INLINE void Eigen::internal::storeComplexAccumulator	(	Index	i,
		Index	j,
		const DataMapper &	data,
		const Packet &	alphaReal,
		const Packet &	alphaImag,
		__vector_quad *	accReal,
		__vector_quad *	accImag
	)

strides() [1/3]

template<int Layout, typename IndexType , int NumDims>

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

(

const DSizes< IndexType, NumDims > &

dimensions

)

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

)

strides() [3/3]

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

EIGEN_STRONG_INLINE DSizes< std::ptrdiff_t, sizeof...(Indices)> Eigen::internal::strides

(

const Sizes< Indices... > &

sizes

)

swap()

template<typename T >

void Eigen::internal::swap	(	scoped_array< T > &	a,
		scoped_array< T > &	b
	)

symm_pack_complex_lhs_helper()

template<typename Scalar , typename Index , int StorageOrder>

EIGEN_STRONG_INLINE void Eigen::internal::symm_pack_complex_lhs_helper	(	std::complex< Scalar > *	blockA,
		const std::complex< Scalar > *	_lhs,
		Index	lhsStride,
		Index	cols,
		Index	rows
	)

symm_pack_complex_rhs_helper()

template<typename Scalar , typename Index , int StorageOrder, int N>

EIGEN_STRONG_INLINE void Eigen::internal::symm_pack_complex_rhs_helper	(	std::complex< Scalar > *	blockB,
		const std::complex< Scalar > *	_rhs,
		Index	rhsStride,
		Index	rows,
		Index	cols,
		Index	k2
	)

symm_pack_lhs_helper()

template<typename Scalar , typename Index , int StorageOrder>

EIGEN_STRONG_INLINE void Eigen::internal::symm_pack_lhs_helper	(	Scalar *	blockA,
		const Scalar *	_lhs,
		Index	lhsStride,
		Index	cols,
		Index	rows
	)

symm_pack_rhs_helper()

template<typename Scalar , typename Index , int StorageOrder, int N>

EIGEN_STRONG_INLINE void Eigen::internal::symm_pack_rhs_helper	(	Scalar *	blockB,
		const Scalar *	_rhs,
		Index	rhsStride,
		Index	rows,
		Index	cols,
		Index	k2
	)

throw_std_bad_alloc()

EIGEN_DEVICE_FUNC void Eigen::internal::throw_std_bad_alloc ( )

inline

treePostorder()

template<typename IndexVector >

void Eigen::internal::treePostorder	(	typename IndexVector::Scalar	n,
		IndexVector &	parent,
		IndexVector &	post
	)

Post order a tree.

Parameters

n	the number of nodes
parent	Input tree
post	postordered tree

tridiagonalization_inplace() [1/2]

template<typename MatrixType , typename DiagonalType , typename SubDiagonalType , typename CoeffVectorType >

EIGEN_DEVICE_FUNC void Eigen::internal::tridiagonalization_inplace	(	MatrixType &	mat,
		DiagonalType &	diag,
		SubDiagonalType &	subdiag,
		CoeffVectorType &	hcoeffs,
		bool	extractQ
	)

Performs a full tridiagonalization in place.

Parameters

[in,out]	mat	On input, the selfadjoint matrix whose tridiagonal decomposition is to be computed. Only the lower triangular part referenced. The rest is left unchanged. On output, the orthogonal matrix Q in the decomposition if extractQ is true.
[out]	diag	The diagonal of the tridiagonal matrix T in the decomposition.
[out]	subdiag	The subdiagonal of the tridiagonal matrix T in the decomposition.
[in]	extractQ	If true, the orthogonal matrix Q in the decomposition is computed and stored in mat.

Computes the tridiagonal decomposition of the selfadjoint matrix mat in place such that where is unitary and a real symmetric tridiagonal matrix.

The tridiagonal matrix T is passed to the output parameters diag and subdiag. If extractQ is true, then the orthogonal matrix Q is passed to mat. Otherwise the lower part of the matrix mat is destroyed.

The vectors diag and subdiag are not resized. The function assumes that they are already of the correct size. The length of the vector diag should equal the number of rows in mat, and the length of the vector subdiag should be one left.

This implementation contains an optimized path for 3-by-3 matrices which is especially useful for plane fitting.

Note

Currently, it requires two temporary vectors to hold the intermediate Householder coefficients, and to reconstruct the matrix Q from the Householder reflectors.

Example (this uses the same matrix as the example in Tridiagonalization::Tridiagonalization(const MatrixType&)):

Output:

See also

class Tridiagonalization

tridiagonalization_inplace() [2/2]

template<typename MatrixType , typename CoeffVectorType >

EIGEN_DEVICE_FUNC void Eigen::internal::tridiagonalization_inplace	(	MatrixType &	matA,
		CoeffVectorType &	hCoeffs
	)

trig_reduce_huge()

float Eigen::internal::trig_reduce_huge ( float  xf, int *  quadrant  )

inline

twoprod() [1/3]

template<typename Packet >

EIGEN_STRONG_INLINE void Eigen::internal::twoprod	(	const Packet &	x,
		const Packet &	y,
		Packet &	p_hi,
		Packet &	p_lo
	)

twoprod() [2/3]

template<typename Packet >

EIGEN_STRONG_INLINE void Eigen::internal::twoprod	(	const Packet &	x_hi,
		const Packet &	x_lo,
		const Packet &	y,
		Packet &	p_hi,
		Packet &	p_lo
	)

twoprod() [3/3]

template<typename Packet >

EIGEN_STRONG_INLINE void Eigen::internal::twoprod	(	const Packet &	x_hi,
		const Packet &	x_lo,
		const Packet &	y_hi,
		const Packet &	y_lo,
		Packet &	p_hi,
		Packet &	p_lo
	)

twosum()

template<typename Packet >

EIGEN_STRONG_INLINE void Eigen::internal::twosum	(	const Packet &	x_hi,
		const Packet &	x_lo,
		const Packet &	y_hi,
		const Packet &	y_lo,
		Packet &	s_hi,
		Packet &	s_lo
	)

upperbidiagonalization_blocked_helper()

template<typename MatrixType >

void Eigen::internal::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
	)

upperbidiagonalization_inplace_blocked()

template<typename MatrixType , typename BidiagType >

void Eigen::internal::upperbidiagonalization_inplace_blocked	(	MatrixType &	A,
		BidiagType &	bidiagonal,
		Index	maxBlockSize = 32,
		typename MatrixType::Scalar *	= 0
	)

upperbidiagonalization_inplace_unblocked()

template<typename MatrixType >

void Eigen::internal::upperbidiagonalization_inplace_unblocked	(	MatrixType &	mat,
		typename MatrixType::RealScalar *	diagonal,
		typename MatrixType::RealScalar *	upper_diagonal,
		typename MatrixType::Scalar *	tempData = 0
	)

useSpecificBlockingSizes()

template<typename Index >

bool Eigen::internal::useSpecificBlockingSizes ( Index &  k, Index &  m, Index &  n  )

inline

vec2d_unpackhi()

EIGEN_STRONG_INLINE Packet2d Eigen::internal::vec2d_unpackhi	(	const Packet2d &	a,
		const Packet2d &	b
	)

vec2d_unpacklo()

EIGEN_STRONG_INLINE Packet2d Eigen::internal::vec2d_unpacklo	(	const Packet2d &	a,
		const Packet2d &	b
	)

vec4f_movehl()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec4f_movehl	(	const Packet4f &	a,
		const Packet4f &	b
	)

vec4f_movelh()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec4f_movelh	(	const Packet4f &	a,
		const Packet4f &	b
	)

vec4f_swizzle1()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec4f_swizzle1	(	const Packet4f &	a,
		int	p,
		int	q,
		int	r,
		int	s
	)

vec4f_swizzle2()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec4f_swizzle2	(	const Packet4f &	a,
		const Packet4f &	b,
		int	p,
		int	q,
		int	r,
		int	s
	)

vec4f_unpackhi()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec4f_unpackhi	(	const Packet4f &	a,
		const Packet4f &	b
	)

vec4f_unpacklo()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec4f_unpacklo	(	const Packet4f &	a,
		const Packet4f &	b
	)

vec_splat_packet4f()

template<int element>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec_splat_packet4f

(

const Packet4f &

from

)

veltkamp_splitting()

template<typename Packet >

EIGEN_STRONG_INLINE void Eigen::internal::veltkamp_splitting	(	const Packet &	x,
		Packet &	x_hi,
		Packet &	x_lo
	)

Variable Documentation

arg_prod

template<typename... Ts>

EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE decltype(reduce< product_op, Ts... >::run((*((Ts *) 0))...) Eigen::internal::arg_prod) (Ts... ts) ( Ts...  ts )

constexpr

arg_sum

template<typename... Ts>

constexpr EIGEN_STRONG_INLINE decltype(reduce< sum_op, Ts... >::run((*((Ts *) 0))...) Eigen::internal::arg_sum) (Ts... ts) ( Ts...  ts )

constexpr

defaultL1CacheSize

const std::ptrdiff_t Eigen::internal::defaultL1CacheSize = EIGEN_SET_DEFAULT_L1_CACHE_SIZE(16*1024)

defaultL2CacheSize

const std::ptrdiff_t Eigen::internal::defaultL2CacheSize = EIGEN_SET_DEFAULT_L2_CACHE_SIZE(512*1024)

defaultL3CacheSize

const std::ptrdiff_t Eigen::internal::defaultL3CacheSize = EIGEN_SET_DEFAULT_L3_CACHE_SIZE(512*1024)

y

const Scalar & Eigen::internal::y

Initial value:

{
  return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(x, y)