Eigen::internal Namespace Reference

Namespaces
namespace	anonymous_namespace{Macros.h}
namespace	std_fallback

Classes
struct	abs2_impl
struct	abs2_impl_default
struct	abs2_impl_default< Scalar, true >
struct	abs2_retval
struct	abs_knowing_score
struct	abs_knowing_score< Scalar, typename scalar_score_coeff_op< Scalar >::Score_is_abs >
struct	accessors_level
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	all_unroller
struct	all_unroller< Derived, 0 >
struct	all_unroller< Derived, Dynamic >
struct	always_void
class	AmbiVector
struct	any_unroller
struct	any_unroller< Derived, 0 >
struct	any_unroller< Derived, Dynamic >
struct	apply_rotation_in_the_plane_selector
struct	apply_rotation_in_the_plane_selector< Scalar, OtherScalar, SizeAtCompileTime, MinAlignment, true >
struct	arg_default_impl
struct	arg_default_impl< Scalar, true >
struct	arg_impl
struct	arg_retval
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, SolveWithGuess< DecType, RhsType, GuessType >, 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 >
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_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 >
class	BandMatrix
	Represents a rectangular matrix with a banded storage. More...
class	BandMatrixBase
class	BandMatrixWrapper
struct	BandShape
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
class	blas_data_mapper
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	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	CacheSizes
struct	cast_impl
struct	cast_return_type
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	coeff_visitor
struct	column_dfs_traits
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::SSE, double, MatrixType, ResultType >
struct	compute_inverse_size4< Architecture::SSE, float, MatrixType, ResultType >
class	compute_matrix_flags
struct	conditional
struct	conditional< false, Then, Else >
struct	conj_expr_if
struct	conj_helper
struct	conj_helper< Packet1cd, Packet1cd, false, true >
struct	conj_helper< Packet1cd, Packet1cd, true, false >
struct	conj_helper< Packet1cd, Packet1cd, true, true >
struct	conj_helper< Packet2cd, Packet2cd, false, true >
struct	conj_helper< Packet2cd, Packet2cd, true, false >
struct	conj_helper< Packet2cd, Packet2cd, true, true >
struct	conj_helper< Packet2cf, Packet2cf, false, true >
struct	conj_helper< Packet2cf, Packet2cf, true, false >
struct	conj_helper< Packet2cf, Packet2cf, true, true >
struct	conj_helper< Packet4cf, Packet4cf, false, true >
struct	conj_helper< Packet4cf, Packet4cf, true, false >
struct	conj_helper< Packet4cf, Packet4cf, true, true >
struct	conj_helper< RealScalar, std::complex< RealScalar >, false, Conj >
struct	conj_helper< Scalar, Scalar, false, false >
struct	conj_helper< std::complex< RealScalar >, RealScalar, Conj, false >
struct	conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, false, true >
struct	conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, true, false >
struct	conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, true, true >
struct	conj_if
struct	conj_if< false >
struct	conj_if< true >
struct	conj_impl
struct	conj_impl< Scalar, true >
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	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::SSE, 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_size
struct	default_digits10_impl
struct	default_digits10_impl< T, false, false >
struct	default_digits10_impl< T, false, true >
struct	default_packet_traits
struct	Dense2Dense
struct	Dense2Triangular
struct	dense_assignment_loop
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	Diagonal2Dense
struct	Diagonal2Sparse
struct	diagonal_product_evaluator_base
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	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	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	eval
struct	eval< Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense >
struct	eval< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense >
struct	eval< T, Dense >
struct	eval< T, DiagonalShape >
struct	eval< T, Sparse >
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< 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< ReturnByValue< Derived > >
struct	evaluator< Select< ConditionMatrixType, ThenMatrixType, ElseMatrixType > >
struct	evaluator< Solve< Decomposition, RhsType > >
struct	evaluator< SolveWithGuess< Decomposition, RhsType, GuessType > >
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	extract_data_selector
struct	extract_data_selector< T, false >
struct	false_type
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	FullPivHouseholderQRMatrixQReturnType
	Expression type for return value of FullPivHouseholderQR::matrixQ() More...
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< linspaced_op< Scalar, PacketType > >
struct	functor_traits< max_coeff_visitor< Scalar > >
struct	functor_traits< min_coeff_visitor< Scalar > >
struct	functor_traits< mul_assign_op< DstScalar, SrcScalar > >
struct	functor_traits< scalar_abs2_op< Scalar > >
struct	functor_traits< scalar_abs_op< Scalar > >
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_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::half, float > >
struct	functor_traits< scalar_cast_op< float, Eigen::half > >
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_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< Scalar > >
struct	functor_traits< scalar_difference_op< LhsScalar, RhsScalar > >
struct	functor_traits< scalar_exp_op< Scalar > >
struct	functor_traits< scalar_floor_op< Scalar > >
struct	functor_traits< scalar_hypot_op< Scalar, Scalar > >
struct	functor_traits< scalar_identity_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_log10_op< Scalar > >
struct	functor_traits< scalar_log1p_op< Scalar > >
struct	functor_traits< scalar_log_op< Scalar > >
struct	functor_traits< scalar_max_op< LhsScalar, RhsScalar > >
struct	functor_traits< scalar_min_op< LhsScalar, RhsScalar > >
struct	functor_traits< scalar_opposite_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_round_op< Scalar > >
struct	functor_traits< scalar_rsqrt_op< Scalar > >
struct	functor_traits< scalar_score_coeff_op< Scalar > >
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< Scalar > >
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< 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	gebp_kernel
struct	gebp_madd_selector
struct	gebp_madd_selector< CJ, T, T, T, T >
class	gebp_traits
class	gebp_traits< RealScalar, std::complex< RealScalar >, false, _ConjRhs >
class	gebp_traits< std::complex< RealScalar >, RealScalar, _ConjLhs, false >
class	gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs >
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< Scalar, Index, DataMapper, Pack1, Pack2, ColMajor, Conjugate, PanelMode >
struct	gemm_pack_lhs< Scalar, Index, DataMapper, Pack1, Pack2, RowMajor, Conjugate, PanelMode >
struct	gemm_pack_rhs
struct	gemm_pack_rhs< Scalar, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode >
struct	gemm_pack_rhs< Scalar, 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_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 >
struct	general_matrix_matrix_product
struct	general_matrix_matrix_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, ColMajor >
struct	general_matrix_matrix_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, RowMajor >
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, UpLo, Version >
struct	general_matrix_matrix_triangular_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, RowMajor, 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 >
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, GemmProduct >
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< 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
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	get_factor
struct	get_factor< Scalar, typename NumTraits< Scalar >::Real >
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	has_binary_operator
struct	has_binary_operator< linspaced_op< Scalar, PacketType >, 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, PacketType >, 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, PacketType >, 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	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	IndexBased
class	inner_iterator_selector
class	inner_iterator_selector< XprType, IndexBased >
class	inner_iterator_selector< XprType, IteratorBased >
struct	inner_stride_at_compile_time
struct	inner_stride_at_compile_time< Derived, false >
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	inverse_impl
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< 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< 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_impl
struct	is_diagonal
struct	is_diagonal< DiagonalBase< T > >
struct	is_diagonal< DiagonalMatrix< T, S > >
struct	is_diagonal< DiagonalWrapper< T > >
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	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	IteratorBased
struct	kernel_retval
struct	kernel_retval< FullPivLU< _MatrixType > >
class	kernel_retval_base
struct	lapacke_llt
struct	ldlt_inplace
struct	ldlt_inplace< Lower >
struct	ldlt_inplace< Upper >
struct	LDLT_Traits
struct	LDLT_Traits< MatrixType, Lower >
struct	LDLT_Traits< MatrixType, Upper >
class	level3_blocking
struct	linspaced_op
struct	linspaced_op_impl
struct	linspaced_op_impl< Scalar, Packet, false >
struct	linspaced_op_impl< Scalar, Packet, 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_retval
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 >
class	make_proper_matrix_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_swap_impl
struct	matrix_swap_impl< MatrixTypeA, MatrixTypeB, true >
struct	matrix_type_times_scalar_type
struct	max_coeff_visitor
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, true >
struct	meta_no
class	meta_sqrt
class	meta_sqrt< Y, InfX, SupX, true >
struct	meta_yes
struct	min_coeff_visitor
struct	mul_assign_op
struct	nested_eval
struct	nested_eval< ReturnByValue< Derived >, n, PlainObject >
class	no_assignment_operator
class	noncopyable
struct	norm1_default_impl
struct	norm1_default_impl< Scalar, false >
struct	norm1_impl
struct	norm1_retval
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	outer_stride_at_compile_time
struct	outer_stride_at_compile_time< Derived, false >
union	Packet
struct	Packet1cd
struct	Packet2cd
struct	Packet2cf
union	Packet2cf.__unnamed74__
struct	Packet4cf
struct	Packet4f
struct	packet_traits
struct	packet_traits< const T >
struct	packet_traits< double >
struct	packet_traits< float >
struct	packet_traits< int >
struct	packet_traits< int32_t >
struct	packet_traits< std::complex< double > >
struct	packet_traits< std::complex< float > >
struct	PacketBlock
struct	palign_impl
struct	palign_impl< Offset, Packet16f >
struct	palign_impl< Offset, Packet1cd >
struct	palign_impl< Offset, Packet2cd >
struct	palign_impl< Offset, Packet2cf >
struct	palign_impl< Offset, Packet2d >
struct	palign_impl< Offset, Packet4cf >
struct	palign_impl< Offset, Packet4d >
struct	palign_impl< Offset, Packet4f >
struct	palign_impl< Offset, Packet4i >
struct	palign_impl< Offset, Packet8d >
struct	palign_impl< Offset, Packet8f >
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	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_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
struct	pow_impl
struct	pow_impl< ScalarX, ScalarY, true >
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_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 >
struct	product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, LhsSelfAdjoint, ConjugateLhs, RhsStorageOrder, RhsSelfAdjoint, ConjugateRhs, RowMajor >
struct	product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, true, ConjugateLhs, RhsStorageOrder, false, ConjugateRhs, ColMajor >
struct	product_size_category
struct	product_triangular_matrix_matrix
struct	product_triangular_matrix_matrix< Scalar, Index, Mode, false, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor, Version >
struct	product_triangular_matrix_matrix< Scalar, Index, Mode, LhsIsTriangular, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, RowMajor, Version >
struct	product_triangular_matrix_matrix< Scalar, Index, Mode, true, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor, 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	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	quat_conj
struct	quat_conj< Architecture::SSE, Derived, double >
struct	quat_conj< Architecture::SSE, Derived, float >
struct	quat_product
struct	quat_product< Architecture::SSE, Derived, OtherDerived, double >
struct	quat_product< Architecture::SSE, 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< 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	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
class	redux_evaluator
struct	redux_impl
struct	redux_impl< Func, Derived, DefaultTraversal, CompleteUnrolling >
struct	redux_impl< Func, Derived, DefaultTraversal, NoUnrolling >
struct	redux_impl< Func, Derived, LinearVectorizedTraversal, CompleteUnrolling >
struct	redux_impl< Func, Derived, LinearVectorizedTraversal, NoUnrolling >
struct	redux_impl< Func, Derived, SliceVectorizedTraversal, Unrolling >
struct	redux_novec_unroller
struct	redux_novec_unroller< Func, Derived, Start, 0 >
struct	redux_novec_unroller< Func, Derived, Start, 1 >
struct	redux_traits
struct	redux_vec_unroller
struct	redux_vec_unroller< Func, Derived, 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	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	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_retval
struct	scalar_abs2_op
struct	scalar_abs_op
struct	scalar_acos_op
struct	scalar_arg_op
struct	scalar_asin_op
struct	scalar_atan_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::half, float >
struct	scalar_cast_op< float, Eigen::half >
struct	scalar_cast_op< int, Eigen::half >
struct	scalar_ceil_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_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_floor_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_hypot_op
struct	scalar_hypot_op< Scalar, Scalar >
struct	scalar_identity_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_log_op
struct	scalar_max_op
struct	scalar_min_op
struct	scalar_opposite_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_round_op
struct	scalar_rsqrt_op
struct	scalar_score_coeff_op
struct	scalar_sign_op
struct	scalar_sign_op< Scalar, false >
struct	scalar_sign_op< Scalar, true >
struct	scalar_sin_op
struct	scalar_sinh_op
struct	scalar_sqrt_op
struct	scalar_square_op
struct	scalar_sum_op
struct	scalar_sum_op< bool, bool >
struct	scalar_tan_op
struct	scalar_tanh_op
struct	scalar_zeta_op
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	significant_decimals_impl
struct	simplicial_cholesky_grab_input
struct	simplicial_cholesky_grab_input< MatrixType, MatrixType >
struct	size_at_compile_time
struct	size_of_xpr_at_compile_time
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_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	static_assertion
struct	static_assertion< true >
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 >
struct	sub_assign_op
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	swap_assign_op
struct	symm_pack_lhs
struct	symm_pack_rhs
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	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	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< 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< EvalToTemp< ArgType > >
struct	traits< ForceAlignedAccess< ExpressionType > >
struct	traits< FullPivHouseholderQR< _MatrixType > >
struct	traits< FullPivHouseholderQRMatrixQReturnType< MatrixType > >
struct	traits< FullPivLU< _MatrixType > >
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< HouseholderSequence< VectorsType, CoeffsType, Side > >
struct	traits< image_retval_base< DecompositionType > >
struct	traits< Inverse< XprType > >
struct	traits< JacobiSVD< _MatrixType, QRPreconditioner > >
struct	traits< kernel_retval_base< DecompositionType > >
struct	traits< LeastSquaresConjugateGradient< _MatrixType, _Preconditioner > >
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< MatrixWrapper< ExpressionType > >
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< 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< 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< 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_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 >
struct	triangular_solve_matrix< Scalar, Index, OnTheRight, Mode, Conjugate, TriStorageOrder, ColMajor >
struct	triangular_solve_matrix< Scalar, Index, Side, Mode, Conjugate, TriStorageOrder, RowMajor >
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< double, float >
struct	type_casting_traits< float, double >
struct	type_casting_traits< float, int >
struct	type_casting_traits< int, float >
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< Inverse< ArgType > >
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< ArgType, Mode >, 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)>
struct	unitOrthogonal_selector
struct	unitOrthogonal_selector< Derived, 2 >
struct	unitOrthogonal_selector< Derived, 3 >
struct	unpacket_traits
struct	unpacket_traits< DoublePacket< Packet > >
struct	unpacket_traits< Packet16f >
struct	unpacket_traits< Packet16i >
struct	unpacket_traits< Packet1cd >
struct	unpacket_traits< Packet2cd >
struct	unpacket_traits< Packet2cf >
struct	unpacket_traits< Packet2d >
struct	unpacket_traits< Packet4cf >
struct	unpacket_traits< Packet4d >
struct	unpacket_traits< Packet4f >
struct	unpacket_traits< Packet4i >
struct	unpacket_traits< Packet8d >
struct	unpacket_traits< Packet8f >
struct	unpacket_traits< Packet8i >
class	UpperBidiagonalization
class	variable_if_dynamic
class	variable_if_dynamic< T, Dynamic >
class	variable_if_dynamicindex
class	variable_if_dynamicindex< T, DynamicIndex >
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, 1 >
struct	visitor_impl< Visitor, Derived, Dynamic >
class	vml_assign_traits

Typedefs
typedef __vector float	Packet4f
typedef __vector int	Packet4i
typedef __vector unsigned int	Packet4ui
typedef __vector __bool int	Packet4bi
typedef __vector short int	Packet8i
typedef __vector unsigned char	Packet16uc
typedef __m256	Packet8f
typedef __m256d	Packet4d
typedef __m512	Packet16f
typedef __m512i	Packet16i
typedef __m512d	Packet8d
typedef float32x2_t	Packet2f
typedef int32x2_t	Packet2i
typedef __m128d	Packet2d
typedef const char *	SsePrefetchPtrType
typedef __vector unsigned long long	Packet2ul
typedef __vector long long	Packet2l
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	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 }

Functions
template<typename MatrixType , typename VectorType >
static Index	llt_rank_update_lower (MatrixType &mat, const VectorType &vec, const typename MatrixType::RealScalar &sigma)
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)
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	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 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 Packet2cf	preduxp< Packet2cf > (const Packet2cf *vecs)
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)
static	_EIGEN_DECLARE_CONST_Packet4f (1, 1.0f)
static	_EIGEN_DECLARE_CONST_Packet4f (half, 0.5f)
static	_EIGEN_DECLARE_CONST_Packet4i (0x7f, 0x7f)
static	_EIGEN_DECLARE_CONST_Packet4i (23, 23)
static	_EIGEN_DECLARE_CONST_Packet4f_FROM_INT (inv_mant_mask, ~0x7f800000)
static	_EIGEN_DECLARE_CONST_Packet4f_FROM_INT (min_norm_pos, 0x00800000)
static	_EIGEN_DECLARE_CONST_Packet4f_FROM_INT (minus_inf, 0xff800000)
static	_EIGEN_DECLARE_CONST_Packet4f_FROM_INT (minus_nan, 0xffffffff)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_SQRTHF, 0.707106781186547524f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_log_p0, 7.0376836292E-2f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_log_p1, - 1.1514610310E-1f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_log_p2, 1.1676998740E-1f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_log_p3, - 1.2420140846E-1f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_log_p4,+1.4249322787E-1f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_log_p5, - 1.6668057665E-1f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_log_p6,+2.0000714765E-1f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_log_p7, - 2.4999993993E-1f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_log_p8,+3.3333331174E-1f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_log_q1, -2.12194440e-4f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_log_q2, 0.693359375f)
static	_EIGEN_DECLARE_CONST_Packet4f (exp_hi, 88.3762626647950f)
static	_EIGEN_DECLARE_CONST_Packet4f (exp_lo, -88.3762626647949f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_LOG2EF, 1.44269504088896341f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_exp_C1, 0.693359375f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_exp_C2, -2.12194440e-4f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_exp_p0, 1.9875691500E-4f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_exp_p1, 1.3981999507E-3f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_exp_p2, 8.3334519073E-3f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_exp_p3, 4.1665795894E-2f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_exp_p4, 1.6666665459E-1f)
static	_EIGEN_DECLARE_CONST_Packet4f (cephes_exp_p5, 5.0000001201E-1f)
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	prsqrt< Packet4f > (const Packet4f &x)
static	_EIGEN_DECLARE_CONST_FAST_Packet4f (ZERO, 0)
static	_EIGEN_DECLARE_CONST_FAST_Packet4i (ZERO, 0)
static	_EIGEN_DECLARE_CONST_FAST_Packet4i (ONE, 1)
static	_EIGEN_DECLARE_CONST_FAST_Packet4i (MINUS16,-16)
static	_EIGEN_DECLARE_CONST_FAST_Packet4i (MINUS1,-1)
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<>
EIGEN_STRONG_INLINE Packet4f	pload< Packet4f > (const float *from)
template<>
EIGEN_STRONG_INLINE Packet4i	pload< Packet4i > (const int *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 Packet4f	pset1< Packet4f > (const float &from)
template<>
EIGEN_STRONG_INLINE Packet4i	pset1< Packet4i > (const int &from)
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<>
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<>
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<>
EIGEN_STRONG_INLINE Packet4f	plset< Packet4f > (const float &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 Packet4i	padd< Packet4i > (const Packet4i &a, const Packet4i &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 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 &, 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 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	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	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 Packet4i	ploadu< Packet4i > (const int *from)
template<>
EIGEN_STRONG_INLINE Packet4f	ploadu< Packet4f > (const float *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 void	pstoreu< int > (int *to, const Packet4i &from)
template<>
EIGEN_STRONG_INLINE void	pstoreu< float > (float *to, const Packet4f &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<>
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 Packet4f	preduxp< Packet4f > (const Packet4f *vecs)
template<>
EIGEN_STRONG_INLINE int	predux< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4i	preduxp< Packet4i > (const Packet4i *vecs)
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 float	predux_min< Packet4f > (const Packet4f &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 int	predux_max< Packet4i > (const Packet4i &a)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet4f, 4 > &kernel)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet4i, 4 > &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 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	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 Packet4cf	preduxp< Packet4cf > (const Packet4cf *vecs)
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	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 Packet2cd	preduxp< Packet2cd > (const Packet2cd *vecs)
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 Packet4cf	pinsertfirst (const Packet4cf &a, std::complex< float > b)
template<>
EIGEN_STRONG_INLINE Packet2cd	pinsertfirst (const Packet2cd &a, std::complex< double > b)
template<>
EIGEN_STRONG_INLINE Packet4cf	pinsertlast (const Packet4cf &a, std::complex< float > b)
template<>
EIGEN_STRONG_INLINE Packet2cd	pinsertlast (const Packet2cd &a, std::complex< double > b)
Packet8i	pshiftleft (Packet8i v, int n)
Packet8f	pshiftright (Packet8f v, int n)
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	plog< 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 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	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 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 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 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	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	pround< Packet8f > (const Packet8f &a)
template<>
EIGEN_STRONG_INLINE Packet4d	pround< 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 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 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 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 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 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	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_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	preduxp< Packet8f > (const Packet8f *vecs)
template<>
EIGEN_STRONG_INLINE Packet4d	preduxp< Packet4d > (const Packet4d *vecs)
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_downto4< 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)
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 Packet8f	pinsertfirst (const Packet8f &a, float b)
template<>
EIGEN_STRONG_INLINE Packet4d	pinsertfirst (const Packet4d &a, double b)
template<>
EIGEN_STRONG_INLINE Packet8f	pinsertlast (const Packet8f &a, float b)
template<>
EIGEN_STRONG_INLINE Packet4d	pinsertlast (const Packet4d &a, double b)
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 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	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 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 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 Packet16f	pdiv< Packet16f > (const Packet16f &a, const Packet16f &b)
template<>
EIGEN_STRONG_INLINE Packet8d	pdiv< Packet8d > (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	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 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 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 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	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	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_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	preduxp< Packet16f > (const Packet16f *vecs)
template<>
EIGEN_STRONG_INLINE Packet8d	preduxp< Packet8d > (const Packet8d *vecs)
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_downto4< Packet16f > (const Packet16f &a)
template<>
EIGEN_STRONG_INLINE Packet4d	predux_downto4< 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)
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 > &, const Packet8d &, const Packet8d &)
uint32x2_t	p2ui_CONJ_XOR ()
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 Packet2cf	preduxp< Packet2cf > (const Packet2cf *vecs)
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_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f	pexp< Packet4f > (const Packet4f &_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	plset< Packet4f > (const float &a)
template<>
EIGEN_STRONG_INLINE Packet4i	plset< Packet4i > (const int32_t &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 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 &, 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 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	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	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 Packet4f	preduxp< Packet4f > (const Packet4f *vecs)
template<>
EIGEN_STRONG_INLINE int32_t	predux< Packet4i > (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4i	preduxp< Packet4i > (const Packet4i *vecs)
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)
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	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 Packet2cf	preduxp< Packet2cf > (const Packet2cf *vecs)
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)
EIGEN_STRONG_INLINE Packet2cf	pcplxflip (const Packet2cf &x)
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	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 Packet1cd	preduxp< Packet1cd > (const Packet1cd *vecs)
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)
template<>
EIGEN_STRONG_INLINE Packet2cf	pblend (const Selector< 2 > &ifPacket, const Packet2cf &thenPacket, const Packet2cf &elsePacket)
template<>
EIGEN_STRONG_INLINE Packet2cf	pinsertfirst (const Packet2cf &a, std::complex< float > b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pinsertfirst (const Packet1cd &, std::complex< double > b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pinsertlast (const Packet2cf &a, std::complex< float > b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pinsertlast (const Packet1cd &, std::complex< double > b)
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 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 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)
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 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 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 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 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 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_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<>
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 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 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 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	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 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 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 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	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_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 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_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 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 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 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 Packet4f	preduxp< Packet4f > (const Packet4f *vecs)
template<>
EIGEN_STRONG_INLINE Packet2d	preduxp< Packet2d > (const Packet2d *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 Packet4i	preduxp< Packet4i > (const Packet4i *vecs)
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 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)
EIGEN_DEVICE_FUNC void	ptranspose (PacketBlock< Packet2d, 2 > &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 Packet4f	pinsertfirst (const Packet4f &a, float b)
template<>
EIGEN_STRONG_INLINE Packet2d	pinsertfirst (const Packet2d &a, double b)
template<>
EIGEN_STRONG_INLINE Packet4f	pinsertlast (const Packet4f &a, float b)
template<>
EIGEN_STRONG_INLINE Packet2d	pinsertlast (const Packet2d &a, double b)
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 Packet2cf	pload< Packet2cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet1cd	pload< Packet1cd > (const std::complex< double > *from)
template<>
EIGEN_STRONG_INLINE Packet2cf	ploadu< Packet2cf > (const std::complex< float > *from)
template<>
EIGEN_STRONG_INLINE Packet1cd	ploadu< Packet1cd > (const std::complex< double > *from)
template<>
EIGEN_STRONG_INLINE void	pstore< std::complex< float > > (std::complex< float > *to, const Packet2cf &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< float > > (std::complex< float > *to, const Packet2cf &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_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 Packet1cd	pgather< std::complex< double >, Packet1cd > (const std::complex< double > *from, Index stride EIGEN_UNUSED)
template<>
EIGEN_DEVICE_FUNC void	pscatter< std::complex< float >, Packet2cf > (std::complex< float > *to, const Packet2cf &from, Index stride)
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 Packet2cf	padd< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	padd< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	psub< Packet2cf > (const Packet2cf &a, const Packet2cf &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 Packet2cf	pnegate (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	pconj (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	pconj (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	pmul< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pmul< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pand< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pand< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	por< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	por< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pxor< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pxor< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	pandnot< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pandnot< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
EIGEN_STRONG_INLINE Packet1cd	ploaddup< Packet1cd > (const std::complex< double > *from)
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 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 std::complex< float >	pfirst< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	preverse (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE Packet2cf	preverse (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE std::complex< double >	predux< Packet1cd > (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	preduxp< Packet1cd > (const Packet1cd *vecs)
template<>
EIGEN_STRONG_INLINE Packet2cf	preduxp< Packet2cf > (const Packet2cf *vecs)
template<>
EIGEN_STRONG_INLINE std::complex< double >	predux_mul< Packet1cd > (const Packet1cd &a)
template<>
EIGEN_STRONG_INLINE std::complex< float >	predux_mul< Packet2cf > (const Packet2cf &a)
template<>
EIGEN_STRONG_INLINE Packet1cd	pdiv< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
EIGEN_STRONG_INLINE Packet2cf	pdiv< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
EIGEN_STRONG_INLINE void	ptranspose (PacketBlock< Packet1cd, 2 > &kernel)
template<>
EIGEN_STRONG_INLINE Packet2cf	pblend (const Selector< 2 > &ifPacket, const Packet2cf &thenPacket, const Packet2cf &elsePacket)
static	_EIGEN_DECLARE_CONST_Packet2d (1, 1.0)
static	_EIGEN_DECLARE_CONST_Packet2d (2, 2.0)
static	_EIGEN_DECLARE_CONST_Packet2d (half, 0.5)
static	_EIGEN_DECLARE_CONST_Packet2d (exp_hi, 709.437)
static	_EIGEN_DECLARE_CONST_Packet2d (exp_lo, -709.436139303)
static	_EIGEN_DECLARE_CONST_Packet2d (cephes_LOG2EF, 1.4426950408889634073599)
static	_EIGEN_DECLARE_CONST_Packet2d (cephes_exp_p0, 1.26177193074810590878e-4)
static	_EIGEN_DECLARE_CONST_Packet2d (cephes_exp_p1, 3.02994407707441961300e-2)
static	_EIGEN_DECLARE_CONST_Packet2d (cephes_exp_p2, 9.99999999999999999910e-1)
static	_EIGEN_DECLARE_CONST_Packet2d (cephes_exp_q0, 3.00198505138664455042e-6)
static	_EIGEN_DECLARE_CONST_Packet2d (cephes_exp_q1, 2.52448340349684104192e-3)
static	_EIGEN_DECLARE_CONST_Packet2d (cephes_exp_q2, 2.27265548208155028766e-1)
static	_EIGEN_DECLARE_CONST_Packet2d (cephes_exp_q3, 2.00000000000000000009e0)
static	_EIGEN_DECLARE_CONST_Packet2d (cephes_exp_C1, 0.693145751953125)
static	_EIGEN_DECLARE_CONST_Packet2d (cephes_exp_C2, 1.42860682030941723212e-6)
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)
static	_EIGEN_DECLARE_CONST_FAST_Packet4i (ONE, 1)
static	_EIGEN_DECLARE_CONST_FAST_Packet2d (ZERO, 0)
static	_EIGEN_DECLARE_CONST_FAST_Packet2l (ZERO, 0)
static	_EIGEN_DECLARE_CONST_FAST_Packet2l (ONE, 1)
std::ostream &	operator<< (std::ostream &s, const Packet2l &v)
std::ostream &	operator<< (std::ostream &s, const Packet2ul &v)
std::ostream &	operator<< (std::ostream &s, const Packet2d &v)
template<int element>
EIGEN_STRONG_INLINE Packet4f	vec_splat_packet4f (const Packet4f &from)
template<>
EIGEN_STRONG_INLINE Packet4i	pload< Packet4i > (const int *from)
template<>
EIGEN_STRONG_INLINE Packet4f	pload< Packet4f > (const float *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< float > (float *to, const Packet4f &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 Packet4f	pset1< Packet4f > (const float &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< 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)
template<>
EIGEN_DEVICE_FUNC Packet4i	pgather< int, Packet4i > (const int *from, Index stride)
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 void	pscatter< int, Packet4i > (int *to, const Packet4i &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_STRONG_INLINE Packet4i	padd< Packet4i > (const Packet4i &a, const Packet4i &b)
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	psub< Packet4i > (const Packet4i &a, const Packet4i &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	pmul< Packet4i > (const Packet4i &a, const Packet4i &b)
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	pdiv< Packet4i > (const Packet4i &a, const Packet4i &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	pnegate (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pnegate (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pnegate (const Packet2d &a)
template<>
EIGEN_STRONG_INLINE Packet4i	pconj (const Packet4i &a)
template<>
EIGEN_STRONG_INLINE Packet4f	pconj (const Packet4f &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 Packet4f	pmadd (const Packet4f &a, const Packet4f &b, const Packet4f &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 Packet4f	plset< Packet4f > (const float &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 Packet4f	pmin< Packet4f > (const Packet4f &a, const Packet4f &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 Packet4f	pmax< Packet4f > (const Packet4f &a, const Packet4f &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 Packet4f	pand< Packet4f > (const Packet4f &a, const Packet4f &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 Packet4f	por< Packet4f > (const Packet4f &a, const Packet4f &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 Packet4f	pxor< Packet4f > (const Packet4f &a, const Packet4f &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 Packet4f	pandnot< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
EIGEN_STRONG_INLINE Packet4f	pround< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet2d	pround< 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	pfloor< Packet4f > (const Packet4f &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 Packet4f	ploadu< Packet4f > (const float *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 Packet4f	ploaddup< Packet4f > (const float *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< float > (float *to, const Packet4f &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< float > (const float *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 float	pfirst< Packet4f > (const Packet4f &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 Packet4f	preverse (const Packet4f &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 Packet4f	pabs< Packet4f > (const Packet4f &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 float	predux< Packet4f > (const Packet4f &a)
template<>
EIGEN_STRONG_INLINE Packet4i	preduxp< Packet4i > (const Packet4i *vecs)
template<>
EIGEN_STRONG_INLINE Packet2d	preduxp< Packet2d > (const Packet2d *vecs)
template<>
EIGEN_STRONG_INLINE Packet4f	preduxp< Packet4f > (const Packet4f *vecs)
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 float	predux_mul< Packet4f > (const Packet4f &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 float	predux_min< Packet4f > (const Packet4f &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 float	predux_max< Packet4f > (const Packet4f &a)
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<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 , 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 >
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.
static void	check_DenseIndex_is_signed ()
template<int Alignment, typename Derived >
static Index	first_aligned (const DenseBase< Derived > &m)
template<typename Derived >
static Index	first_default_aligned (const DenseBase< Derived > &m)
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 Packet >
EIGEN_DEVICE_FUNC Packet	padd (const Packet &a, const Packet &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<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<typename Packet >
EIGEN_DEVICE_FUNC Packet	pdiv (const Packet &a, const Packet &b)
template<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<typename Packet >
EIGEN_DEVICE_FUNC Packet	pabs (const Packet &a)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	parg (const Packet &a)
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	pandnot (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 Packet	pset1 (const typename unpacket_traits< Packet >::type &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 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 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 unpacket_traits< Packet >::type	pfirst (const Packet &a)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	preduxp (const Packet *vecs)
template<typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type	predux (const Packet &a)
template<typename Packet >
EIGEN_DEVICE_FUNC conditional<(unpacket_traits< Packet >::size%8)==0, typenameunpacket_traits< Packet >::half, Packet >::type	predux_downto4 (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<typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type	predux_max (const Packet &a)
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	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	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	pceil (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<int Offset, typename PacketType >
void	palign (PacketType &first, const PacketType &second)
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 Packet >
EIGEN_DEVICE_FUNC Packet	pinsertfirst (const Packet &a, typename unpacket_traits< Packet >::type b)
template<typename Packet >
EIGEN_DEVICE_FUNC Packet	pinsertlast (const Packet &a, typename unpacket_traits< Packet >::type b)
template<typename Derived >
std::ostream &	print_matrix (std::ostream &s, const Derived &_m, const IOFormat &fmt)
template<typename OldType , typename NewType >
EIGEN_DEVICE_FUNC NewType	cast (const OldType &x)
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_STRONG_INLINE RealScalar	positive_real_hypot (const RealScalar &x, const RealScalar &y)
	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	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	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 CJ , typename A , typename B , typename C , typename T >
EIGEN_STRONG_INLINE void	gebp_madd (const CJ &cj, A &a, B &b, C &c, T &t)
template<typename Packet >
DoublePacket< Packet >	padd (const DoublePacket< Packet > &a, const DoublePacket< Packet > &b)
template<typename Packet >
const DoublePacket< Packet > &	predux_downto4 (const DoublePacket< Packet > &a)
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 Derived >
NumTraits< typenametraits< Derived >::Scalar >::Real	blueNorm_impl (const EigenBase< Derived > &_vec)
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 >
const T::Scalar *	extract_data (const T &m)
void	assert_fail (const char *condition, const char *function, const char *file, int line)
template<typename T >
EIGEN_DEVICE_FUNC void	ignore_unused_variable (const T &)
EIGEN_DEVICE_FUNC void	throw_std_bad_alloc ()
void *	handmade_aligned_malloc (std::size_t size)
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 >
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 >
const T *	return_ptr ()
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 >
bool	is_same_dense (const T1 &mat1, const T2 &mat2, typename enable_if< has_direct_access< T1 >::ret &&has_direct_access< T2 >::ret, T1 >::type *=0)
template<typename T1 , typename T2 >
bool	is_same_dense (const T1 &, const T2 &, typename enable_if<!(has_direct_access< T1 >::ret &&has_direct_access< T2 >::ret), T1 >::type *=0)
	EIGEN_MEMBER_FUNCTOR (squaredNorm, Size *NumTraits< Scalar >::MulCost+(Size-1) *NumTraits< Scalar >::AddCost)
	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 (sum,(Size-1) *NumTraits< Scalar >::AddCost)
	EIGEN_MEMBER_FUNCTOR (mean,(Size-1) *NumTraits< Scalar >::AddCost+NumTraits< Scalar >::MulCost)
	EIGEN_MEMBER_FUNCTOR (minCoeff,(Size-1) *NumTraits< Scalar >::AddCost)
	EIGEN_MEMBER_FUNCTOR (maxCoeff,(Size-1) *NumTraits< Scalar >::AddCost)
	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_MEMBER_FUNCTOR (prod,(Size-1) *NumTraits< Scalar >::MulCost)
template<typename MatrixType , typename DiagType , typename SubDiagType >
ComputationInfo	computeFromTridiagonal_impl (DiagType &diag, SubDiagType &subdiag, const Index maxIterations, bool computeEigenvectors, MatrixType &eivec)
template<int StorageOrder, typename RealScalar , typename Scalar , typename Index >
static EIGEN_DEVICE_FUNC void	tridiagonal_qr_step (RealScalar *diag, RealScalar *subdiag, Index start, Index end, Scalar *matrixQ, Index n)
template<typename MatrixType , typename CoeffVectorType >
void	tridiagonalization_inplace (MatrixType &matA, CoeffVectorType &hCoeffs)
template<typename MatrixType , typename DiagonalType , typename SubDiagonalType >
void	tridiagonalization_inplace (MatrixType &mat, DiagonalType &diag, SubDiagonalType &subdiag, bool extractQ)
	Performs a full tridiagonalization in place.
template<typename Scalar , int Dim>
static EIGEN_DEVICE_FUNC Matrix< Scalar, 2, 2 >	toRotationMatrix (const Scalar &s)
template<typename Scalar , int Dim, typename OtherDerived >
static EIGEN_DEVICE_FUNC Matrix< Scalar, Dim, Dim >	toRotationMatrix (const RotationBase< OtherDerived, Dim > &r)
template<typename Scalar , int Dim, typename OtherDerived >
static EIGEN_DEVICE_FUNC const MatrixBase< OtherDerived > &	toRotationMatrix (const MatrixBase< OtherDerived > &mat)
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 >
void	apply_rotation_in_the_plane (DenseBase< VectorX > &xpr_x, DenseBase< VectorY > &xpr_y, const JacobiRotation< OtherScalar > &j)
template<typename Derived >
const Derived::Scalar	bruteforce_det3_helper (const MatrixBase< Derived > &matrix, int a, int b, int c)
template<typename Derived >
const Derived::Scalar	bruteforce_det4_helper (const MatrixBase< Derived > &matrix, int j, int k, int m, int n)
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 >
static StorageIndex	cs_wclear (StorageIndex mark, StorageIndex lemax, StorageIndex *w, StorageIndex n)
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 Lhs , typename Rhs , typename ResultType >
static void	conservative_sparse_sparse_product_impl (const Lhs &lhs, const Rhs &rhs, ResultType &res, bool sortedInsertion=false)
template<typename Lhs , typename Rhs , typename ResultType >
static void	sparse_sparse_to_dense_product_impl (const Lhs &lhs, const Rhs &rhs, ResultType &res)
template<typename DstXprType , typename SrcXprType >
void	assign_sparse_to_sparse (DstXprType &dst, const SrcXprType &src)
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 Lhs , typename Rhs , typename ResultType >
static void	sparse_sparse_product_with_pruning_impl (const Lhs &lhs, const Rhs &rhs, ResultType &res, const typename ResultType::RealScalar &tolerance)
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<typename Scalar , typename IndexType >
bool	GetMarketLine (std::stringstream &line, IndexType &M, IndexType &N, IndexType &i, IndexType &j, Scalar &value)
template<typename Scalar , typename IndexType >
bool	GetMarketLine (std::stringstream &line, IndexType &M, IndexType &N, IndexType &i, IndexType &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 >
void	PutMatrixElt (Scalar value, int row, int col, std::ofstream &out)
template<typename Scalar >
void	PutMatrixElt (std::complex< Scalar > value, int row, int 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)

Variables
static Packet4ui	p4ui_CONJ_XOR = vec_mergeh((Packet4ui)p4i_ZERO, (Packet4ui)p4f_MZERO)
static Packet4f	p4f_MZERO = (Packet4f) vec_sl((Packet4ui)p4i_MINUS1, (Packet4ui)p4i_MINUS1)
static Packet4f	p4f_ONE = vec_ctf(p4i_ONE, 0)
static Packet4f	p4f_COUNTDOWN = { 0.0, 1.0, 2.0, 3.0 }
static Packet4i	p4i_COUNTDOWN = { 0, 1, 2, 3 }
static Packet16uc	p16uc_REVERSE32 = { 12,13,14,15, 8,9,10,11, 4,5,6,7, 0,1,2,3 }
static Packet16uc	p16uc_DUPLICATE32_HI = { 0,1,2,3, 0,1,2,3, 4,5,6,7, 4,5,6,7 }
static Packet16uc	p16uc_FORWARD = p16uc_REVERSE32
static Packet16uc	p16uc_REVERSE64 = { 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 }
static Packet16uc	p16uc_PSET32_WODD = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 1), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 3), 8)
static Packet16uc	p16uc_PSET32_WEVEN = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 0), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 2), 8)
static Packet16uc	p16uc_HALF64_0_16 = vec_sld(vec_splat((Packet16uc) vec_abs(p4i_MINUS16), 0), (Packet16uc)p4i_ZERO, 8)
static Packet16uc	p16uc_PSET64_HI = (Packet16uc) vec_mergeh((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN)
static Packet16uc	p16uc_PSET64_LO = (Packet16uc) vec_mergel((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN)
static Packet16uc	p16uc_TRANSPOSE64_HI = p16uc_PSET64_HI + p16uc_HALF64_0_16
static Packet16uc	p16uc_TRANSPOSE64_LO = p16uc_PSET64_LO + p16uc_HALF64_0_16
static Packet16uc	p16uc_COMPLEX32_REV = vec_sld(p16uc_REVERSE32, p16uc_REVERSE32, 8)
static Packet16uc	p16uc_COMPLEX32_REV2 = vec_sld(p16uc_PSET64_HI, p16uc_PSET64_LO, 8)
static Packet2ul	p2ul_CONJ_XOR1 = (Packet2ul) vec_sld((Packet4ui) p2d_ZERO_, (Packet4ui) p2l_ZERO, 8)
static Packet2ul	p2ul_CONJ_XOR2 = (Packet2ul) vec_sld((Packet4ui) p2l_ZERO, (Packet4ui) p2d_ZERO_, 8)
static Packet2d	p2d_ONE = { 1.0, 1.0 }
static Packet2d	p2d_ZERO_ = { -0.0, -0.0 }
static Packet4i	p4i_COUNTDOWN = { 0, 1, 2, 3 }
static Packet4f	p4f_COUNTDOWN = { 0.0, 1.0, 2.0, 3.0 }
static Packet2d	p2d_COUNTDOWN = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet16uc>(p2d_ZERO), reinterpret_cast<Packet16uc>(p2d_ONE), 8))
static Packet16uc	p16uc_PSET64_HI = { 0,1,2,3, 4,5,6,7, 0,1,2,3, 4,5,6,7 }
static Packet16uc	p16uc_DUPLICATE32_HI = { 0,1,2,3, 0,1,2,3, 4,5,6,7, 4,5,6,7 }
static Packet16uc	p16uc_FORWARD = { 0,1,2,3, 4,5,6,7, 8,9,10,11, 12,13,14,15 }
static Packet16uc	p16uc_REVERSE32 = { 12,13,14,15, 8,9,10,11, 4,5,6,7, 0,1,2,3 }
static Packet16uc	p16uc_REVERSE64 = { 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 }
static Packet16uc	p16uc_PSET32_WODD = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 0), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 2), 8)
static Packet16uc	p16uc_PSET32_WEVEN = vec_sld(p16uc_DUPLICATE32_HI, (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 3), 8)
static Packet16uc	p16uc_PSET64_LO = (Packet16uc) vec_mergel((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN)
static Packet16uc	p16uc_TRANSPOSE64_HI = { 0,1,2,3, 4,5,6,7, 16,17,18,19, 20,21,22,23}
static Packet16uc	p16uc_TRANSPOSE64_LO = { 8,9,10,11, 12,13,14,15, 24,25,26,27, 28,29,30,31}
const Scalar &	y
const std::ptrdiff_t	defaultL1CacheSize = 16*1024
const std::ptrdiff_t	defaultL2CacheSize = 512*1024
const std::ptrdiff_t	defaultL3CacheSize = 512*1024

---

Class Documentation

Eigen::internal::abs2_retval

struct Eigen::internal::abs2_retval

template<typename Scalar>
struct Eigen::internal::abs2_retval< Scalar >

Class Members
typedef Real	type

Eigen::internal::add_const

struct Eigen::internal::add_const

template<typename T>
struct Eigen::internal::add_const< T >

Class Members
typedef const T	type

Eigen::internal::add_const< T & >

struct Eigen::internal::add_const< T & >

template<typename T>
struct Eigen::internal::add_const< T & >

Class Members
typedef T &	type

Eigen::internal::add_const_on_value_type

struct Eigen::internal::add_const_on_value_type

template<typename T>
struct Eigen::internal::add_const_on_value_type< T >

Inheritance diagram for Eigen::internal::add_const_on_value_type< T >:

Class Members
typedef const T	type

Eigen::internal::add_const_on_value_type< T & >

struct Eigen::internal::add_const_on_value_type< T & >

template<typename T>
struct Eigen::internal::add_const_on_value_type< T & >

Class Members
typedef T const &	type

Eigen::internal::add_const_on_value_type< T * >

struct Eigen::internal::add_const_on_value_type< T * >

template<typename T>
struct Eigen::internal::add_const_on_value_type< T * >

Class Members
typedef T const *	type

Eigen::internal::add_const_on_value_type< T *const >

struct Eigen::internal::add_const_on_value_type< T *const >

template<typename T>
struct Eigen::internal::add_const_on_value_type< T *const >

Class Members
typedef T const *const	type

Eigen::internal::add_const_on_value_type< T const *const >

struct Eigen::internal::add_const_on_value_type< T const *const >

template<typename T>
struct Eigen::internal::add_const_on_value_type< T const *const >

Class Members
typedef T const *const	type

Eigen::internal::add_const_on_value_type_if_arithmetic

struct Eigen::internal::add_const_on_value_type_if_arithmetic

template<typename T>
struct Eigen::internal::add_const_on_value_type_if_arithmetic< T >

Class Members
typedef value, T, type >::type	type

Eigen::internal::always_void

struct Eigen::internal::always_void

template<typename T>
struct Eigen::internal::always_void< T >

Class Members
typedef void	type

Eigen::internal::arg_retval

struct Eigen::internal::arg_retval

template<typename Scalar>
struct Eigen::internal::arg_retval< Scalar >

Class Members
typedef Real	type

Eigen::internal::assign_op< DstScalar, void >

struct Eigen::internal::assign_op< DstScalar, void >

template<typename DstScalar>
struct Eigen::internal::assign_op< DstScalar, void >

Eigen::internal::Assignment

struct Eigen::internal::Assignment

template<typename DstXprType, typename SrcXprType, typename Functor, typename Kind = typename AssignmentKind< typename evaluator_traits<DstXprType>::Shape , typename evaluator_traits<SrcXprType>::Shape >::Kind, typename EnableIf = void>
struct Eigen::internal::Assignment< DstXprType, SrcXprType, Functor, Kind, EnableIf >

Eigen::internal::AssignmentKind

struct Eigen::internal::AssignmentKind

template<typename, typename>
struct Eigen::internal::AssignmentKind< typename, typename >

Class Members
typedef EigenBase2EigenBase	Kind

Eigen::internal::AssignmentKind< DenseShape, BandShape >

struct Eigen::internal::AssignmentKind< DenseShape, BandShape >

Class Members
typedef EigenBase2EigenBase	Kind

Eigen::internal::AssignmentKind< DenseShape, DenseShape >

struct Eigen::internal::AssignmentKind< DenseShape, DenseShape >

Class Members
typedef Dense2Dense	Kind

Eigen::internal::AssignmentKind< DenseShape, DiagonalShape >

struct Eigen::internal::AssignmentKind< DenseShape, DiagonalShape >

Class Members
typedef Diagonal2Dense	Kind

Eigen::internal::AssignmentKind< DenseShape, HomogeneousShape >

struct Eigen::internal::AssignmentKind< DenseShape, HomogeneousShape >

Class Members
typedef Dense2Dense	Kind

Eigen::internal::AssignmentKind< DenseShape, PermutationShape >

struct Eigen::internal::AssignmentKind< DenseShape, PermutationShape >

Class Members
typedef EigenBase2EigenBase	Kind

Eigen::internal::AssignmentKind< DenseShape, SparseShape >

struct Eigen::internal::AssignmentKind< DenseShape, SparseShape >

Class Members
typedef Sparse2Dense	Kind

Eigen::internal::AssignmentKind< DenseShape, SparseTriangularShape >

struct Eigen::internal::AssignmentKind< DenseShape, SparseTriangularShape >

Class Members
typedef Sparse2Dense	Kind

Eigen::internal::AssignmentKind< DenseShape, TriangularShape >

struct Eigen::internal::AssignmentKind< DenseShape, TriangularShape >

Class Members
typedef Triangular2Dense	Kind

Eigen::internal::AssignmentKind< SparseSelfAdjointShape, SparseShape >

struct Eigen::internal::AssignmentKind< SparseSelfAdjointShape, SparseShape >

Class Members
typedef Sparse2Sparse	Kind

Eigen::internal::AssignmentKind< SparseShape, DiagonalShape >

struct Eigen::internal::AssignmentKind< SparseShape, DiagonalShape >

Class Members
typedef Diagonal2Sparse	Kind

Eigen::internal::AssignmentKind< SparseShape, SparseSelfAdjointShape >

struct Eigen::internal::AssignmentKind< SparseShape, SparseSelfAdjointShape >

Class Members
typedef SparseSelfAdjoint2Sparse	Kind

Eigen::internal::AssignmentKind< SparseShape, SparseShape >

struct Eigen::internal::AssignmentKind< SparseShape, SparseShape >

Class Members
typedef Sparse2Sparse	Kind

Eigen::internal::AssignmentKind< SparseShape, SparseTriangularShape >

struct Eigen::internal::AssignmentKind< SparseShape, SparseTriangularShape >

Class Members
typedef Sparse2Sparse	Kind

Eigen::internal::AssignmentKind< TriangularShape, DenseShape >

struct Eigen::internal::AssignmentKind< TriangularShape, DenseShape >

Class Members
typedef Dense2Triangular	Kind

Eigen::internal::AssignmentKind< TriangularShape, TriangularShape >

struct Eigen::internal::AssignmentKind< TriangularShape, TriangularShape >

Class Members
typedef Triangular2Triangular	Kind

Eigen::internal::BandShape

struct Eigen::internal::BandShape

Eigen::internal::binary_evaluator

struct Eigen::internal::binary_evaluator

template<typename T, typename LhsKind = typename evaluator_traits<typename T::Lhs>::Kind, typename RhsKind = typename evaluator_traits<typename T::Rhs>::Kind, typename LhsScalar = typename traits<typename T::Lhs>::Scalar, typename RhsScalar = typename traits<typename T::Rhs>::Scalar>
struct Eigen::internal::binary_evaluator< T, LhsKind, RhsKind, LhsScalar, RhsScalar >

Inheritance diagram for Eigen::internal::binary_evaluator< T, LhsKind, RhsKind, LhsScalar, RhsScalar >:

Eigen::internal::binary_result_of_select

struct Eigen::internal::binary_result_of_select

template<typename Func, typename ArgType0, typename ArgType1, int SizeOf = sizeof(has_none)>
struct Eigen::internal::binary_result_of_select< Func, ArgType0, ArgType1, SizeOf >

Class Members
typedef type	type

Eigen::internal::binary_result_of_select< Func, ArgType0, ArgType1, sizeof(has_std_result_type)>

struct Eigen::internal::binary_result_of_select< Func, ArgType0, ArgType1, sizeof(has_std_result_type)>

template<typename Func, typename ArgType0, typename ArgType1>
struct Eigen::internal::binary_result_of_select< Func, ArgType0, ArgType1, sizeof(has_std_result_type)>

Class Members
typedef result_type	type

Eigen::internal::binary_result_of_select< Func, ArgType0, ArgType1, sizeof(has_tr1_result)>

struct Eigen::internal::binary_result_of_select< Func, ArgType0, ArgType1, sizeof(has_tr1_result)>

template<typename Func, typename ArgType0, typename ArgType1>
struct Eigen::internal::binary_result_of_select< Func, ArgType0, ArgType1, sizeof(has_tr1_result)>

Class Members
typedef template type	type

Eigen::internal::binary_sparse_evaluator

struct Eigen::internal::binary_sparse_evaluator

template<typename XprType>
struct Eigen::internal::binary_sparse_evaluator< XprType >

Eigen::internal::cast_return_type

struct Eigen::internal::cast_return_type

template<typename XprType, typename CastType>
struct Eigen::internal::cast_return_type< XprType, CastType >

Class Members
typedef type	_CastType
typedef Scalar	CurrentScalarType
typedef Scalar	NewScalarType
typedef value, constXprType &, CastType >::type	type

Eigen::internal::cholmod_configure_matrix

struct Eigen::internal::cholmod_configure_matrix

template<typename Scalar>
struct Eigen::internal::cholmod_configure_matrix< Scalar >

Eigen::internal::compute_inverse_and_det_with_check

struct Eigen::internal::compute_inverse_and_det_with_check

template<typename MatrixType, typename ResultType, int Size = MatrixType::RowsAtCompileTime>
struct Eigen::internal::compute_inverse_and_det_with_check< MatrixType, ResultType, Size >

Eigen::internal::conditional

struct Eigen::internal::conditional

template<bool Condition, typename Then, typename Else>
struct Eigen::internal::conditional< Condition, Then, Else >

Inheritance diagram for Eigen::internal::conditional< Condition, Then, Else >:

Class Members
typedef Then	type

Eigen::internal::conditional< false, Then, Else >

struct Eigen::internal::conditional< false, Then, Else >

template<typename Then, typename Else>
struct Eigen::internal::conditional< false, Then, Else >

Class Members
typedef Else	type

Eigen::internal::conj_if

struct Eigen::internal::conj_if

template<bool Conjugate>
struct Eigen::internal::conj_if< Conjugate >

Eigen::internal::conj_retval

struct Eigen::internal::conj_retval

template<typename Scalar>
struct Eigen::internal::conj_retval< Scalar >

Class Members
typedef Scalar	type

Eigen::internal::conservative_sparse_sparse_product_selector

struct Eigen::internal::conservative_sparse_sparse_product_selector

template<typename Lhs, typename Rhs, typename ResultType, int LhsStorageOrder = (traits<Lhs>::Flags&RowMajorBit) ? RowMajor : ColMajor, int RhsStorageOrder = (traits<Rhs>::Flags&RowMajorBit) ? RowMajor : ColMajor, int ResStorageOrder = (traits<ResultType>::Flags&RowMajorBit) ? RowMajor : ColMajor>
struct Eigen::internal::conservative_sparse_sparse_product_selector< Lhs, Rhs, ResultType, LhsStorageOrder, RhsStorageOrder, ResStorageOrder >

Eigen::internal::constructor_without_unaligned_array_assert

struct Eigen::internal::constructor_without_unaligned_array_assert

Eigen::internal::cwise_promote_storage_type

struct Eigen::internal::cwise_promote_storage_type

template<typename A, typename B, typename Functor>
struct Eigen::internal::cwise_promote_storage_type< A, B, Functor >

Eigen::internal::cwise_promote_storage_type< A, A, Functor >

struct Eigen::internal::cwise_promote_storage_type< A, A, Functor >

template<typename A, typename Functor>
struct Eigen::internal::cwise_promote_storage_type< A, A, Functor >

Class Members
typedef A	ret

Eigen::internal::cwise_promote_storage_type< A, Dense, Functor >

struct Eigen::internal::cwise_promote_storage_type< A, Dense, Functor >

template<typename A, typename Functor>
struct Eigen::internal::cwise_promote_storage_type< A, Dense, Functor >

Class Members
typedef Dense	ret

Eigen::internal::cwise_promote_storage_type< Dense, B, Functor >

struct Eigen::internal::cwise_promote_storage_type< Dense, B, Functor >

template<typename B, typename Functor>
struct Eigen::internal::cwise_promote_storage_type< Dense, B, Functor >

Class Members
typedef Dense	ret

Eigen::internal::cwise_promote_storage_type< Dense, Dense, Functor >

struct Eigen::internal::cwise_promote_storage_type< Dense, Dense, Functor >

template<typename Functor>
struct Eigen::internal::cwise_promote_storage_type< Dense, Dense, Functor >

Class Members
typedef Dense	ret

Eigen::internal::cwise_promote_storage_type< Dense, Sparse, Functor >

struct Eigen::internal::cwise_promote_storage_type< Dense, Sparse, Functor >

template<typename Functor>
struct Eigen::internal::cwise_promote_storage_type< Dense, Sparse, Functor >

Class Members
typedef Sparse	ret

Eigen::internal::cwise_promote_storage_type< Sparse, Dense, Functor >

struct Eigen::internal::cwise_promote_storage_type< Sparse, Dense, Functor >

template<typename Functor>
struct Eigen::internal::cwise_promote_storage_type< Sparse, Dense, Functor >

Class Members
typedef Sparse	ret

Eigen::internal::Dense2Dense

struct Eigen::internal::Dense2Dense

Eigen::internal::Dense2Triangular

struct Eigen::internal::Dense2Triangular

Eigen::internal::dense_assignment_loop

struct Eigen::internal::dense_assignment_loop

template<typename Kernel, int Traversal = Kernel::AssignmentTraits::Traversal, int Unrolling = Kernel::AssignmentTraits::Unrolling>
struct Eigen::internal::dense_assignment_loop< Kernel, Traversal, Unrolling >

Eigen::internal::dense_xpr_base

struct Eigen::internal::dense_xpr_base

template<typename Derived, typename XprKind = typename traits<Derived>::XprKind>
struct Eigen::internal::dense_xpr_base< Derived, XprKind >

Eigen::internal::dense_xpr_base< Derived, ArrayXpr >

struct Eigen::internal::dense_xpr_base< Derived, ArrayXpr >

template<typename Derived>
struct Eigen::internal::dense_xpr_base< Derived, ArrayXpr >

Class Members
typedef ArrayBase< Derived >	type

Eigen::internal::dense_xpr_base< Derived, MatrixXpr >

struct Eigen::internal::dense_xpr_base< Derived, MatrixXpr >

template<typename Derived>
struct Eigen::internal::dense_xpr_base< Derived, MatrixXpr >

Class Members
typedef MatrixBase< Derived >	type

Eigen::internal::Diagonal2Dense

struct Eigen::internal::Diagonal2Dense

Eigen::internal::Diagonal2Sparse

struct Eigen::internal::Diagonal2Sparse

Eigen::internal::DoublePacket

struct Eigen::internal::DoublePacket

template<typename Packet>
struct Eigen::internal::DoublePacket< Packet >

Collaboration diagram for Eigen::internal::DoublePacket< Packet >:

Class Members
Packet	first
Packet	second

Eigen::internal::EigenBase2EigenBase

struct Eigen::internal::EigenBase2EigenBase

Eigen::internal::enable_if

struct Eigen::internal::enable_if

template<bool Condition, typename T = void>
struct Eigen::internal::enable_if< Condition, T >

Eigen::internal::enable_if< true, T >

struct Eigen::internal::enable_if< true, T >

template<typename T>
struct Eigen::internal::enable_if< true, T >

Class Members
typedef T	type

Eigen::internal::enable_if_ref

struct Eigen::internal::enable_if_ref

template<typename T, typename Derived>
struct Eigen::internal::enable_if_ref< T, Derived >

Eigen::internal::enable_if_ref< Ref< T >, Derived >

struct Eigen::internal::enable_if_ref< Ref< T >, Derived >

template<typename T, typename Derived>
struct Eigen::internal::enable_if_ref< Ref< T >, Derived >

Class Members
typedef Derived	type

Eigen::internal::EnableIf

struct Eigen::internal::EnableIf

template<bool>
struct Eigen::internal::EnableIf< bool >

Eigen::internal::etor_product_coeff_impl

struct Eigen::internal::etor_product_coeff_impl

template<int Traversal, int UnrollingIndex, typename Lhs, typename Rhs, typename RetScalar>
struct Eigen::internal::etor_product_coeff_impl< Traversal, UnrollingIndex, Lhs, Rhs, RetScalar >

Eigen::internal::etor_product_packet_impl

struct Eigen::internal::etor_product_packet_impl

template<int StorageOrder, int UnrollingIndex, typename Lhs, typename Rhs, typename Packet, int LoadMode>
struct Eigen::internal::etor_product_packet_impl< StorageOrder, UnrollingIndex, Lhs, Rhs, Packet, LoadMode >

Eigen::internal::eval

struct Eigen::internal::eval

template<typename T, typename StorageKind = typename traits<T>::StorageKind>
struct Eigen::internal::eval< T, StorageKind >

Eigen::internal::eval< Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense >

struct Eigen::internal::eval< Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense >

template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
struct Eigen::internal::eval< Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense >

Class Members
typedef const Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > &	type

Eigen::internal::eval< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense >

struct Eigen::internal::eval< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense >

template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
struct Eigen::internal::eval< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense >

Class Members
typedef const Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > &	type

Eigen::internal::eval< T, Dense >

struct Eigen::internal::eval< T, Dense >

template<typename T>
struct Eigen::internal::eval< T, Dense >

Class Members
typedef type	type

Eigen::internal::eval< T, DiagonalShape >

struct Eigen::internal::eval< T, DiagonalShape >

template<typename T>
struct Eigen::internal::eval< T, DiagonalShape >

Class Members
typedef type	type

Eigen::internal::evaluator_traits< Homogeneous< ArgType, Direction > >

struct Eigen::internal::evaluator_traits< Homogeneous< ArgType, Direction > >

template<typename ArgType, int Direction>
struct Eigen::internal::evaluator_traits< Homogeneous< ArgType, Direction > >

Class Members
typedef Kind	Kind
typedef HomogeneousShape	Shape

Eigen::internal::evaluator_traits< SelfAdjointView< MatrixType, Mode > >

struct Eigen::internal::evaluator_traits< SelfAdjointView< MatrixType, Mode > >

template<typename MatrixType, unsigned int Mode>
struct Eigen::internal::evaluator_traits< SelfAdjointView< MatrixType, Mode > >

Class Members
typedef Kind	Kind
typedef SelfAdjointShape	Shape

Eigen::internal::evaluator_traits< SparseQRMatrixQReturnType< SparseQRType > >

struct Eigen::internal::evaluator_traits< SparseQRMatrixQReturnType< SparseQRType > >

template<typename SparseQRType>
struct Eigen::internal::evaluator_traits< SparseQRMatrixQReturnType< SparseQRType > >

Class Members
typedef Kind	Kind
typedef MatrixType	MatrixType
typedef SparseShape	Shape

Eigen::internal::evaluator_traits< SparseSelfAdjointView< MatrixType, Mode > >

struct Eigen::internal::evaluator_traits< SparseSelfAdjointView< MatrixType, Mode > >

template<typename MatrixType, unsigned int Mode>
struct Eigen::internal::evaluator_traits< SparseSelfAdjointView< MatrixType, Mode > >

Class Members
typedef Kind	Kind
typedef SparseSelfAdjointShape	Shape

Eigen::internal::evaluator_traits< TriangularView< MatrixType, Mode > >

struct Eigen::internal::evaluator_traits< TriangularView< MatrixType, Mode > >

template<typename MatrixType, unsigned int Mode>
struct Eigen::internal::evaluator_traits< TriangularView< MatrixType, Mode > >

Class Members
typedef Kind	Kind
typedef Shape, TriangularShape >::type	Shape

Eigen::internal::find_best_packet

struct Eigen::internal::find_best_packet

template<typename T, int Size>
struct Eigen::internal::find_best_packet< T, Size >

Class Members
typedef type >::type	type

Eigen::internal::find_best_packet_helper

struct Eigen::internal::find_best_packet_helper

template<int Size, typename PacketType, bool Stop = Size==Dynamic || (Size%unpacket_traits<PacketType>::size)==0 || is_same<PacketType,typename unpacket_traits<PacketType>::half>::value>
struct Eigen::internal::find_best_packet_helper< Size, PacketType, Stop >

Eigen::internal::find_best_packet_helper< Size, PacketType, false >

struct Eigen::internal::find_best_packet_helper< Size, PacketType, false >

template<int Size, typename PacketType>
struct Eigen::internal::find_best_packet_helper< Size, PacketType, false >

Class Members
typedef half >::type	type

Eigen::internal::find_best_packet_helper< Size, PacketType, true >

struct Eigen::internal::find_best_packet_helper< Size, PacketType, true >

template<int Size, typename PacketType>
struct Eigen::internal::find_best_packet_helper< Size, PacketType, true >

Class Members
typedef PacketType	type

Eigen::internal::gemm_blocking_space

class Eigen::internal::gemm_blocking_space

template<int StorageOrder, typename LhsScalar, typename RhsScalar, int MaxRows, int MaxCols, int MaxDepth, int KcFactor = 1, bool FiniteAtCompileTime = MaxRows!=Dynamic && MaxCols!=Dynamic && MaxDepth != Dynamic>
class Eigen::internal::gemm_blocking_space< StorageOrder, LhsScalar, RhsScalar, MaxRows, MaxCols, MaxDepth, KcFactor, FiniteAtCompileTime >

Eigen::internal::gemm_pack_lhs

struct Eigen::internal::gemm_pack_lhs

template<typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, int StorageOrder, bool Conjugate = false, bool PanelMode = false>
struct Eigen::internal::gemm_pack_lhs< Scalar, Index, DataMapper, Pack1, Pack2, StorageOrder, Conjugate, PanelMode >

Eigen::internal::gemm_pack_rhs

struct Eigen::internal::gemm_pack_rhs

template<typename Scalar, typename Index, typename DataMapper, int nr, int StorageOrder, bool Conjugate = false, bool PanelMode = false>
struct Eigen::internal::gemm_pack_rhs< Scalar, Index, DataMapper, nr, StorageOrder, Conjugate, PanelMode >

Eigen::internal::gemv_dense_selector

struct Eigen::internal::gemv_dense_selector

template<int Side, int StorageOrder, bool BlasCompatible>
struct Eigen::internal::gemv_dense_selector< Side, StorageOrder, BlasCompatible >

Eigen::internal::gemv_static_vector_if

struct Eigen::internal::gemv_static_vector_if

template<typename Scalar, int Size, int MaxSize, bool Cond>
struct Eigen::internal::gemv_static_vector_if< Scalar, Size, MaxSize, Cond >

Eigen::internal::general_matrix_matrix_product

struct Eigen::internal::general_matrix_matrix_product

template<typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs, typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs, int ResStorageOrder>
struct Eigen::internal::general_matrix_matrix_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, ResStorageOrder >

Eigen::internal::general_matrix_matrix_triangular_product

struct Eigen::internal::general_matrix_matrix_triangular_product

template<typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs, typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs, int ResStorageOrder, int UpLo, int Version = Specialized>
struct Eigen::internal::general_matrix_matrix_triangular_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, ResStorageOrder, UpLo, Version >

Inheritance diagram for Eigen::internal::general_matrix_matrix_triangular_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, ResStorageOrder, UpLo, Version >:

Eigen::internal::general_matrix_vector_product

struct Eigen::internal::general_matrix_vector_product

template<typename Index, typename LhsScalar, typename LhsMapper, int LhsStorageOrder, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version = Specialized>
struct Eigen::internal::general_matrix_vector_product< Index, LhsScalar, LhsMapper, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsMapper, ConjugateRhs, Version >

Eigen::internal::general_matrix_vector_product_gemv

struct Eigen::internal::general_matrix_vector_product_gemv

template<typename Index, typename LhsScalar, int StorageOrder, bool ConjugateLhs, typename RhsScalar, bool ConjugateRhs>
struct Eigen::internal::general_matrix_vector_product_gemv< Index, LhsScalar, StorageOrder, ConjugateLhs, RhsScalar, ConjugateRhs >

Eigen::internal::generic_matrix_wrapper

class Eigen::internal::generic_matrix_wrapper

template<typename MatrixType, bool MatrixFree = !internal::is_ref_compatible<MatrixType>::value>
class Eigen::internal::generic_matrix_wrapper< MatrixType, MatrixFree >

Eigen::internal::generic_product_impl

struct Eigen::internal::generic_product_impl

template<typename Lhs, typename Rhs, typename LhsShape = typename evaluator_traits<Lhs>::Shape, typename RhsShape = typename evaluator_traits<Rhs>::Shape, int ProductType = internal::product_type<Lhs,Rhs>::value>
struct Eigen::internal::generic_product_impl< Lhs, Rhs, LhsShape, RhsShape, ProductType >

Eigen::internal::generic_xpr_base

struct Eigen::internal::generic_xpr_base

template<typename Derived, typename XprKind = typename traits<Derived>::XprKind, typename StorageKind = typename traits<Derived>::StorageKind>
struct Eigen::internal::generic_xpr_base< Derived, XprKind, StorageKind >

Eigen::internal::generic_xpr_base< Derived, MatrixXpr, SolverStorage >

struct Eigen::internal::generic_xpr_base< Derived, MatrixXpr, SolverStorage >

template<typename Derived>
struct Eigen::internal::generic_xpr_base< Derived, MatrixXpr, SolverStorage >

Class Members
typedef SolverBase< Derived >	type

Eigen::internal::generic_xpr_base< Derived, MatrixXpr, Sparse >

struct Eigen::internal::generic_xpr_base< Derived, MatrixXpr, Sparse >

template<typename Derived>
struct Eigen::internal::generic_xpr_base< Derived, MatrixXpr, Sparse >

Class Members
typedef SparseMatrixBase< Derived >	type

Eigen::internal::generic_xpr_base< Derived, XprKind, Dense >

struct Eigen::internal::generic_xpr_base< Derived, XprKind, Dense >

template<typename Derived, typename XprKind>
struct Eigen::internal::generic_xpr_base< Derived, XprKind, Dense >

Class Members
typedef type	type

Eigen::internal::global_math_functions_filtering_base

struct Eigen::internal::global_math_functions_filtering_base

template<typename T, typename dummy = void>
struct Eigen::internal::global_math_functions_filtering_base< T, dummy >

Class Members
typedef T	type

Eigen::internal::global_math_functions_filtering_base< T, typename always_void< typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl >::type >

struct Eigen::internal::global_math_functions_filtering_base< T, typename always_void< typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl >::type >

template<typename T>
struct Eigen::internal::global_math_functions_filtering_base< T, typename always_void< typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl >::type >

Class Members
typedef Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl	type

Eigen::internal::glue_shapes

struct Eigen::internal::glue_shapes

template<typename S1, typename S2>
struct Eigen::internal::glue_shapes< S1, S2 >

Eigen::internal::glue_shapes< DenseShape, TriangularShape >

struct Eigen::internal::glue_shapes< DenseShape, TriangularShape >

Class Members
typedef TriangularShape	type

Eigen::internal::glue_shapes< SparseShape, SelfAdjointShape >

struct Eigen::internal::glue_shapes< SparseShape, SelfAdjointShape >

Class Members
typedef SparseSelfAdjointShape	type

Eigen::internal::glue_shapes< SparseShape, TriangularShape >

struct Eigen::internal::glue_shapes< SparseShape, TriangularShape >

Class Members
typedef SparseTriangularShape	type

Eigen::internal::has_none

struct Eigen::internal::has_none

Class Members
int	a[1]

Eigen::internal::has_std_result_type

struct Eigen::internal::has_std_result_type

Class Members
int	a[2]

Eigen::internal::has_tr1_result

struct Eigen::internal::has_tr1_result

Class Members
int	a[3]

Eigen::internal::homogeneous_left_product_impl

struct Eigen::internal::homogeneous_left_product_impl

template<typename MatrixType, typename Lhs>
struct Eigen::internal::homogeneous_left_product_impl< MatrixType, Lhs >

Eigen::internal::homogeneous_right_product_impl

struct Eigen::internal::homogeneous_right_product_impl

template<typename MatrixType, typename Rhs>
struct Eigen::internal::homogeneous_right_product_impl< MatrixType, Rhs >

Eigen::internal::HouseholderSequenceShape

struct Eigen::internal::HouseholderSequenceShape

Eigen::internal::hypot_retval

struct Eigen::internal::hypot_retval

template<typename Scalar>
struct Eigen::internal::hypot_retval< Scalar >

Class Members
typedef Real	type

Eigen::internal::imag_ref_retval

struct Eigen::internal::imag_ref_retval

template<typename Scalar>
struct Eigen::internal::imag_ref_retval< Scalar >

Class Members
typedef Real &	type

Eigen::internal::imag_retval

struct Eigen::internal::imag_retval

template<typename Scalar>
struct Eigen::internal::imag_retval< Scalar >

Class Members
typedef Real	type

Eigen::internal::image_retval

struct Eigen::internal::image_retval

template<typename DecompositionType>
struct Eigen::internal::image_retval< DecompositionType >

Eigen::internal::IndexBased

struct Eigen::internal::IndexBased

Eigen::internal::inner_iterator_selector

class Eigen::internal::inner_iterator_selector

template<typename XprType, typename EvaluatorKind>
class Eigen::internal::inner_iterator_selector< XprType, EvaluatorKind >

Inheritance diagram for Eigen::internal::inner_iterator_selector< XprType, EvaluatorKind >:

Eigen::internal::inplace_transpose_selector

struct Eigen::internal::inplace_transpose_selector

template<typename MatrixType, bool IsSquare = (MatrixType::RowsAtCompileTime == MatrixType::ColsAtCompileTime) && MatrixType::RowsAtCompileTime!=Dynamic, bool MatchPacketSize = (int(MatrixType::RowsAtCompileTime) == int(internal::packet_traits<typename MatrixType::Scalar>::size)) && (internal::evaluator<MatrixType>::Flags&PacketAccessBit)>
struct Eigen::internal::inplace_transpose_selector< MatrixType, IsSquare, MatchPacketSize >

Eigen::internal::inverse_impl

struct Eigen::internal::inverse_impl

template<typename MatrixType>
struct Eigen::internal::inverse_impl< MatrixType >

Eigen::internal::IteratorBased

struct Eigen::internal::IteratorBased

Eigen::internal::kernel_retval

struct Eigen::internal::kernel_retval

template<typename DecompositionType>
struct Eigen::internal::kernel_retval< DecompositionType >

Eigen::internal::lapacke_llt

struct Eigen::internal::lapacke_llt

template<typename Scalar>
struct Eigen::internal::lapacke_llt< Scalar >

Eigen::internal::ldlt_inplace

struct Eigen::internal::ldlt_inplace

template<int UpLo>
struct Eigen::internal::ldlt_inplace< UpLo >

Eigen::internal::LDLT_Traits

struct Eigen::internal::LDLT_Traits

template<typename MatrixType, int UpLo>
struct Eigen::internal::LDLT_Traits< MatrixType, UpLo >

Eigen::internal::linspaced_op_impl

struct Eigen::internal::linspaced_op_impl

template<typename Scalar, typename Packet, bool IsInteger>
struct Eigen::internal::linspaced_op_impl< Scalar, Packet, IsInteger >

Inheritance diagram for Eigen::internal::linspaced_op_impl< Scalar, Packet, IsInteger >:

Eigen::internal::llt_inplace

struct Eigen::internal::llt_inplace

template<typename Scalar, int UpLo>
struct Eigen::internal::llt_inplace< Scalar, UpLo >

Eigen::internal::LLT_Traits

struct Eigen::internal::LLT_Traits

template<typename MatrixType, int UpLo>
struct Eigen::internal::LLT_Traits< MatrixType, UpLo >

Eigen::internal::log1p_retval

struct Eigen::internal::log1p_retval

template<typename Scalar>
struct Eigen::internal::log1p_retval< Scalar >

Class Members
typedef Scalar	type

Eigen::internal::LU_GlobalLU_t

struct Eigen::internal::LU_GlobalLU_t

template<typename IndexVector, typename ScalarVector>
struct Eigen::internal::LU_GlobalLU_t< IndexVector, ScalarVector >

Class Members
typedef Scalar	StorageIndex

Class Members
IndexVector	lsub
ScalarVector	lusup
Index	n
Index	num_expansions
Index	nzlmax
Index	nzlumax
Index	nzumax
IndexVector	supno
ScalarVector	ucol
IndexVector	usub
IndexVector	xlsub
IndexVector	xlusup
IndexVector	xsup
IndexVector	xusub

Eigen::internal::make_unsigned

struct Eigen::internal::make_unsigned

template<typename>
struct Eigen::internal::make_unsigned< typename >

Eigen::internal::make_unsigned< char >

struct Eigen::internal::make_unsigned< char >

Class Members
typedef unsigned char	type

Eigen::internal::make_unsigned< signed char >

struct Eigen::internal::make_unsigned< signed char >

Class Members
typedef unsigned char	type

Eigen::internal::make_unsigned< signed int >

struct Eigen::internal::make_unsigned< signed int >

Class Members
typedef unsigned int	type

Eigen::internal::make_unsigned< signed long >

struct Eigen::internal::make_unsigned< signed long >

Class Members
typedef unsigned long	type

Eigen::internal::make_unsigned< signed short >

struct Eigen::internal::make_unsigned< signed short >

Class Members
typedef unsigned short	type

Eigen::internal::make_unsigned< unsigned char >

struct Eigen::internal::make_unsigned< unsigned char >

Class Members
typedef unsigned char	type

Eigen::internal::make_unsigned< unsigned int >

struct Eigen::internal::make_unsigned< unsigned int >

Class Members
typedef unsigned int	type

Eigen::internal::make_unsigned< unsigned long >

struct Eigen::internal::make_unsigned< unsigned long >

Class Members
typedef unsigned long	type

Eigen::internal::make_unsigned< unsigned short >

struct Eigen::internal::make_unsigned< unsigned short >

Class Members
typedef unsigned short	type

Eigen::internal::matrix_type_times_scalar_type

struct Eigen::internal::matrix_type_times_scalar_type

template<typename OtherScalarType, typename MatrixType>
struct Eigen::internal::matrix_type_times_scalar_type< OtherScalarType, MatrixType >

Class Members
typedef ReturnType	ResultScalar
typedef Matrix< ResultScalar, RowsAtCompileTime, ColsAtCompileTime, 0, MaxRowsAtCompileTime, MaxColsAtCompileTime >	Type

Eigen::internal::meta_floor_log2

struct Eigen::internal::meta_floor_log2

template<unsigned int n, int lower = 0, int upper = sizeof(unsigned int) * CHAR_BIT - 1, int selector = meta_floor_log2_selector<n, lower, upper>::value>
struct Eigen::internal::meta_floor_log2< n, lower, upper, selector >

Eigen::internal::meta_floor_log2< n, lower, upper, meta_floor_log2_bogus >

struct Eigen::internal::meta_floor_log2< n, lower, upper, meta_floor_log2_bogus >

template<unsigned int n, int lower, int upper>
struct Eigen::internal::meta_floor_log2< n, lower, upper, meta_floor_log2_bogus >

Eigen::internal::meta_no

struct Eigen::internal::meta_no

Class Members
char	a[2]

Eigen::internal::meta_yes

struct Eigen::internal::meta_yes

Class Members
char	a[1]

Eigen::internal::nested_eval< ReturnByValue< Derived >, n, PlainObject >

struct Eigen::internal::nested_eval< ReturnByValue< Derived >, n, PlainObject >

template<typename Derived, int n, typename PlainObject>
struct Eigen::internal::nested_eval< ReturnByValue< Derived >, n, PlainObject >

Class Members
typedef ReturnType	type

Eigen::internal::norm1_retval

struct Eigen::internal::norm1_retval

template<typename Scalar>
struct Eigen::internal::norm1_retval< Scalar >

Class Members
typedef Real	type

Eigen::internal::nullary_wrapper< Scalar, NullaryOp, false, false, false >

struct Eigen::internal::nullary_wrapper< Scalar, NullaryOp, false, false, false >

template<typename Scalar, typename NullaryOp>
struct Eigen::internal::nullary_wrapper< Scalar, NullaryOp, false, false, false >

Eigen::internal::Packet

union Eigen::internal::Packet

Class Members
double	d[2]
int32_t	i[4]
int64_t	l[2]
uint32_t	ui[4]
uint64_t	ul[2]
Packet2d	v2d
Packet2l	v2l
Packet2ul	v2ul
Packet4i	v4i
Packet4ui	v4ui

Eigen::internal::Packet2cf.__unnamed74__

union Eigen::internal::Packet2cf.__unnamed74__

Class Members
Packet1cd	cd[2]
Packet4f	v

Eigen::internal::Packet4f

struct Eigen::internal::Packet4f

Class Members
Packet2d	v4f[2]

Eigen::internal::PacketBlock

struct Eigen::internal::PacketBlock

template<typename Packet, int N = unpacket_traits<Packet>::size>
struct Eigen::internal::PacketBlock< Packet, N >

Collaboration diagram for Eigen::internal::PacketBlock< Packet, N >:

Class Members
Packet	packet[N]

Eigen::internal::pardiso_traits

struct Eigen::internal::pardiso_traits

template<class Pardiso>
struct Eigen::internal::pardiso_traits< Pardiso >

Eigen::internal::pardiso_traits< PardisoLDLT< _MatrixType, Options > >

struct Eigen::internal::pardiso_traits< PardisoLDLT< _MatrixType, Options > >

template<typename _MatrixType, int Options>
struct Eigen::internal::pardiso_traits< PardisoLDLT< _MatrixType, Options > >

Class Members
typedef _MatrixType	MatrixType
typedef RealScalar	RealScalar
typedef Scalar	Scalar
typedef StorageIndex	StorageIndex

Eigen::internal::pardiso_traits< PardisoLLT< _MatrixType, Options > >

struct Eigen::internal::pardiso_traits< PardisoLLT< _MatrixType, Options > >

template<typename _MatrixType, int Options>
struct Eigen::internal::pardiso_traits< PardisoLLT< _MatrixType, Options > >

Class Members
typedef _MatrixType	MatrixType
typedef RealScalar	RealScalar
typedef Scalar	Scalar
typedef StorageIndex	StorageIndex

Eigen::internal::pardiso_traits< PardisoLU< _MatrixType > >

struct Eigen::internal::pardiso_traits< PardisoLU< _MatrixType > >

template<typename _MatrixType>
struct Eigen::internal::pardiso_traits< PardisoLU< _MatrixType > >

Class Members
typedef _MatrixType	MatrixType
typedef RealScalar	RealScalar
typedef Scalar	Scalar
typedef StorageIndex	StorageIndex

Eigen::internal::pastix_traits

struct Eigen::internal::pastix_traits

template<class Pastix>
struct Eigen::internal::pastix_traits< Pastix >

Eigen::internal::pastix_traits< PastixLDLT< _MatrixType, Options > >

struct Eigen::internal::pastix_traits< PastixLDLT< _MatrixType, Options > >

template<typename _MatrixType, int Options>
struct Eigen::internal::pastix_traits< PastixLDLT< _MatrixType, Options > >

Class Members
typedef _MatrixType	MatrixType
typedef RealScalar	RealScalar
typedef Scalar	Scalar
typedef StorageIndex	StorageIndex

Eigen::internal::pastix_traits< PastixLLT< _MatrixType, Options > >

struct Eigen::internal::pastix_traits< PastixLLT< _MatrixType, Options > >

template<typename _MatrixType, int Options>
struct Eigen::internal::pastix_traits< PastixLLT< _MatrixType, Options > >

Class Members
typedef _MatrixType	MatrixType
typedef RealScalar	RealScalar
typedef Scalar	Scalar
typedef StorageIndex	StorageIndex

Eigen::internal::pastix_traits< PastixLU< _MatrixType > >

struct Eigen::internal::pastix_traits< PastixLU< _MatrixType > >

template<typename _MatrixType>
struct Eigen::internal::pastix_traits< PastixLU< _MatrixType > >

Class Members
typedef _MatrixType	MatrixType
typedef RealScalar	RealScalar
typedef Scalar	Scalar
typedef StorageIndex	StorageIndex

Eigen::internal::perfvalues

struct Eigen::internal::perfvalues

Class Members
Index	colblk
Index	fillfactor
Index	maxsuper
Index	panel_size
Index	relax
Index	rowblk

Eigen::internal::permutation_matrix_product

struct Eigen::internal::permutation_matrix_product

template<typename ExpressionType, int Side, bool Transposed, typename ExpressionShape>
struct Eigen::internal::permutation_matrix_product< ExpressionType, Side, Transposed, ExpressionShape >

Inheritance diagram for Eigen::internal::permutation_matrix_product< ExpressionType, Side, Transposed, ExpressionShape >:

Eigen::internal::plain_col_type

struct Eigen::internal::plain_col_type

template<typename ExpressionType, typename Scalar = typename ExpressionType::Scalar>
struct Eigen::internal::plain_col_type< ExpressionType, Scalar >

Inheritance diagram for Eigen::internal::plain_col_type< ExpressionType, Scalar >:

Class Members
typedef Array< Scalar, RowsAtCompileTime, 1, Options &~RowMajor, MaxRowsAtCompileTime, 1 >	ArrayColType
typedef Matrix< Scalar, RowsAtCompileTime, 1, Options &~RowMajor, MaxRowsAtCompileTime, 1 >	MatrixColType
typedef XprKind, MatrixXpr >::value, MatrixColType, ArrayColType >::type	type

Eigen::internal::plain_matrix_type

struct Eigen::internal::plain_matrix_type

template<typename T, typename StorageKind = typename traits<T>::StorageKind>
struct Eigen::internal::plain_matrix_type< T, StorageKind >

Eigen::internal::plain_matrix_type< T, Dense >

struct Eigen::internal::plain_matrix_type< T, Dense >

template<typename T>
struct Eigen::internal::plain_matrix_type< T, Dense >

Class Members
typedef XprKind, Flags >::type	type

Eigen::internal::plain_matrix_type< T, DiagonalShape >

struct Eigen::internal::plain_matrix_type< T, DiagonalShape >

template<typename T>
struct Eigen::internal::plain_matrix_type< T, DiagonalShape >

Class Members
typedef PlainObject	type

Eigen::internal::plain_matrix_type_dense

struct Eigen::internal::plain_matrix_type_dense

template<typename T, typename BaseClassType, int Flags>
struct Eigen::internal::plain_matrix_type_dense< T, BaseClassType, Flags >

Eigen::internal::plain_matrix_type_dense< T, ArrayXpr, Flags >

struct Eigen::internal::plain_matrix_type_dense< T, ArrayXpr, Flags >

template<typename T, int Flags>
struct Eigen::internal::plain_matrix_type_dense< T, ArrayXpr, Flags >

Class Members
typedef Scalar, RowsAtCompileTime, ColsAtCompileTime, AutoAlign|(Flags &RowMajorBit ? RowMajor :ColMajor), MaxRowsAtCompileTime, MaxColsAtCompileTime >	type

Eigen::internal::plain_matrix_type_dense< T, MatrixXpr, Flags >

struct Eigen::internal::plain_matrix_type_dense< T, MatrixXpr, Flags >

template<typename T, int Flags>
struct Eigen::internal::plain_matrix_type_dense< T, MatrixXpr, Flags >

Class Members
typedef Scalar, RowsAtCompileTime, ColsAtCompileTime, AutoAlign|(Flags &RowMajorBit ? RowMajor :ColMajor), MaxRowsAtCompileTime, MaxColsAtCompileTime >	type

Eigen::internal::plain_object_eval

struct Eigen::internal::plain_object_eval

template<typename T, typename StorageKind = typename traits<T>::StorageKind>
struct Eigen::internal::plain_object_eval< T, StorageKind >

Eigen::internal::plain_object_eval< T, Dense >

struct Eigen::internal::plain_object_eval< T, Dense >

template<typename T>
struct Eigen::internal::plain_object_eval< T, Dense >

Class Members
typedef XprKind, Flags >::type	type

Eigen::internal::plain_row_type

struct Eigen::internal::plain_row_type

template<typename ExpressionType, typename Scalar = typename ExpressionType::Scalar>
struct Eigen::internal::plain_row_type< ExpressionType, Scalar >

Inheritance diagram for Eigen::internal::plain_row_type< ExpressionType, Scalar >:

Class Members
typedef Array< Scalar, 1, ColsAtCompileTime, Options|RowMajor, 1, MaxColsAtCompileTime >	ArrayRowType
typedef Matrix< Scalar, 1, ColsAtCompileTime, Options|RowMajor, 1, MaxColsAtCompileTime >	MatrixRowType
typedef XprKind, MatrixXpr >::value, MatrixRowType, ArrayRowType >::type	type

Eigen::internal::product_evaluator

struct Eigen::internal::product_evaluator

template<typename T, int ProductTag = internal::product_type<typename T::Lhs,typename T::Rhs>::ret, typename LhsShape = typename evaluator_traits<typename T::Lhs>::Shape, typename RhsShape = typename evaluator_traits<typename T::Rhs>::Shape, typename LhsScalar = typename traits<typename T::Lhs>::Scalar, typename RhsScalar = typename traits<typename T::Rhs>::Scalar>
struct Eigen::internal::product_evaluator< T, ProductTag, LhsShape, RhsShape, LhsScalar, RhsScalar >

Inheritance diagram for Eigen::internal::product_evaluator< T, ProductTag, LhsShape, RhsShape, LhsScalar, RhsScalar >:

Eigen::internal::product_promote_storage_type

struct Eigen::internal::product_promote_storage_type

template<typename A, typename B, int ProductTag>
struct Eigen::internal::product_promote_storage_type< A, B, ProductTag >

Eigen::internal::product_promote_storage_type< A, A, ProductTag >

struct Eigen::internal::product_promote_storage_type< A, A, ProductTag >

template<typename A, int ProductTag>
struct Eigen::internal::product_promote_storage_type< A, A, ProductTag >

Class Members
typedef A	ret

Eigen::internal::product_promote_storage_type< A, Dense, ProductTag >

struct Eigen::internal::product_promote_storage_type< A, Dense, ProductTag >

template<typename A, int ProductTag>
struct Eigen::internal::product_promote_storage_type< A, Dense, ProductTag >

Class Members
typedef Dense	ret

Eigen::internal::product_promote_storage_type< A, DiagonalShape, ProductTag >

struct Eigen::internal::product_promote_storage_type< A, DiagonalShape, ProductTag >

template<typename A, int ProductTag>
struct Eigen::internal::product_promote_storage_type< A, DiagonalShape, ProductTag >

Class Members
typedef A	ret

Eigen::internal::product_promote_storage_type< A, PermutationStorage, ProductTag >

struct Eigen::internal::product_promote_storage_type< A, PermutationStorage, ProductTag >

template<typename A, int ProductTag>
struct Eigen::internal::product_promote_storage_type< A, PermutationStorage, ProductTag >

Class Members
typedef A	ret

Eigen::internal::product_promote_storage_type< Dense, B, ProductTag >

struct Eigen::internal::product_promote_storage_type< Dense, B, ProductTag >

template<typename B, int ProductTag>
struct Eigen::internal::product_promote_storage_type< Dense, B, ProductTag >

Class Members
typedef Dense	ret

Eigen::internal::product_promote_storage_type< Dense, Dense, ProductTag >

struct Eigen::internal::product_promote_storage_type< Dense, Dense, ProductTag >

template<int ProductTag>
struct Eigen::internal::product_promote_storage_type< Dense, Dense, ProductTag >

Class Members
typedef Dense	ret

Eigen::internal::product_promote_storage_type< Dense, DiagonalShape, ProductTag >

struct Eigen::internal::product_promote_storage_type< Dense, DiagonalShape, ProductTag >

template<int ProductTag>
struct Eigen::internal::product_promote_storage_type< Dense, DiagonalShape, ProductTag >

Class Members
typedef Dense	ret

Eigen::internal::product_promote_storage_type< Dense, PermutationStorage, ProductTag >

struct Eigen::internal::product_promote_storage_type< Dense, PermutationStorage, ProductTag >

template<int ProductTag>
struct Eigen::internal::product_promote_storage_type< Dense, PermutationStorage, ProductTag >

Class Members
typedef Dense	ret

Eigen::internal::product_promote_storage_type< Dense, Sparse, OuterProduct >

struct Eigen::internal::product_promote_storage_type< Dense, Sparse, OuterProduct >

Class Members
typedef Sparse	ret

Eigen::internal::product_promote_storage_type< DiagonalShape, B, ProductTag >

struct Eigen::internal::product_promote_storage_type< DiagonalShape, B, ProductTag >

template<typename B, int ProductTag>
struct Eigen::internal::product_promote_storage_type< DiagonalShape, B, ProductTag >

Class Members
typedef B	ret

Eigen::internal::product_promote_storage_type< DiagonalShape, Dense, ProductTag >

struct Eigen::internal::product_promote_storage_type< DiagonalShape, Dense, ProductTag >

template<int ProductTag>
struct Eigen::internal::product_promote_storage_type< DiagonalShape, Dense, ProductTag >

Class Members
typedef Dense	ret

Eigen::internal::product_promote_storage_type< PermutationStorage, B, ProductTag >

struct Eigen::internal::product_promote_storage_type< PermutationStorage, B, ProductTag >

template<typename B, int ProductTag>
struct Eigen::internal::product_promote_storage_type< PermutationStorage, B, ProductTag >

Class Members
typedef B	ret

Eigen::internal::product_promote_storage_type< PermutationStorage, Dense, ProductTag >

struct Eigen::internal::product_promote_storage_type< PermutationStorage, Dense, ProductTag >

template<int ProductTag>
struct Eigen::internal::product_promote_storage_type< PermutationStorage, Dense, ProductTag >

Class Members
typedef Dense	ret

Eigen::internal::product_promote_storage_type< PermutationStorage, Sparse, ProductTag >

struct Eigen::internal::product_promote_storage_type< PermutationStorage, Sparse, ProductTag >

template<int ProductTag>
struct Eigen::internal::product_promote_storage_type< PermutationStorage, Sparse, ProductTag >

Class Members
typedef Sparse	ret

Eigen::internal::product_promote_storage_type< Sparse, Dense, OuterProduct >

struct Eigen::internal::product_promote_storage_type< Sparse, Dense, OuterProduct >

Class Members
typedef Sparse	ret

Eigen::internal::product_promote_storage_type< Sparse, PermutationStorage, ProductTag >

struct Eigen::internal::product_promote_storage_type< Sparse, PermutationStorage, ProductTag >

template<int ProductTag>
struct Eigen::internal::product_promote_storage_type< Sparse, PermutationStorage, ProductTag >

Class Members
typedef Sparse	ret

Eigen::internal::product_selfadjoint_matrix

struct Eigen::internal::product_selfadjoint_matrix

template<typename Scalar, typename Index, int LhsStorageOrder, bool LhsSelfAdjoint, bool ConjugateLhs, int RhsStorageOrder, bool RhsSelfAdjoint, bool ConjugateRhs, int ResStorageOrder>
struct Eigen::internal::product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, LhsSelfAdjoint, ConjugateLhs, RhsStorageOrder, RhsSelfAdjoint, ConjugateRhs, ResStorageOrder >

Eigen::internal::product_triangular_matrix_matrix

struct Eigen::internal::product_triangular_matrix_matrix

template<typename Scalar, typename Index, int Mode, bool LhsIsTriangular, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder, bool ConjugateRhs, int ResStorageOrder, int Version = Specialized>
struct Eigen::internal::product_triangular_matrix_matrix< Scalar, Index, Mode, LhsIsTriangular, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ResStorageOrder, Version >

Inheritance diagram for Eigen::internal::product_triangular_matrix_matrix< Scalar, Index, Mode, LhsIsTriangular, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ResStorageOrder, Version >:

Eigen::internal::product_type_selector

struct Eigen::internal::product_type_selector

template<int Rows, int Cols, int Depth>
struct Eigen::internal::product_type_selector< Rows, Cols, Depth >

Eigen::internal::promote_index_type

struct Eigen::internal::promote_index_type

template<typename I1, typename I2>
struct Eigen::internal::promote_index_type< I1, I2 >

Class Members
typedef type	type

Eigen::internal::promote_scalar_arg

struct Eigen::internal::promote_scalar_arg

template<typename ExprScalar, typename T, bool IsSupported>
struct Eigen::internal::promote_scalar_arg< ExprScalar, T, IsSupported >

Eigen::internal::promote_scalar_arg< S, T, true >

struct Eigen::internal::promote_scalar_arg< S, T, true >

template<typename S, typename T>
struct Eigen::internal::promote_scalar_arg< S, T, true >

Class Members
typedef T	type

Eigen::internal::promote_scalar_arg_unsupported

struct Eigen::internal::promote_scalar_arg_unsupported

template<typename ExprScalar, typename T, typename PromotedType, bool ConvertibleToLiteral = internal::is_convertible<T,PromotedType>::value, bool IsSafe = NumTraits<T>::IsInteger || !NumTraits<PromotedType>::IsInteger>
struct Eigen::internal::promote_scalar_arg_unsupported< ExprScalar, T, PromotedType, ConvertibleToLiteral, IsSafe >

Inheritance diagram for Eigen::internal::promote_scalar_arg_unsupported< ExprScalar, T, PromotedType, ConvertibleToLiteral, IsSafe >:

Eigen::internal::promote_scalar_arg_unsupported< S, T, PromotedType, ConvertibleToLiteral, false >

struct Eigen::internal::promote_scalar_arg_unsupported< S, T, PromotedType, ConvertibleToLiteral, false >

template<typename S, typename T, typename PromotedType, bool ConvertibleToLiteral>
struct Eigen::internal::promote_scalar_arg_unsupported< S, T, PromotedType, ConvertibleToLiteral, false >

Eigen::internal::promote_scalar_arg_unsupported< S, T, PromotedType, true, true >

struct Eigen::internal::promote_scalar_arg_unsupported< S, T, PromotedType, true, true >

template<typename S, typename T, typename PromotedType>
struct Eigen::internal::promote_scalar_arg_unsupported< S, T, PromotedType, true, true >

Class Members
typedef PromotedType	type

Eigen::internal::promote_scalar_arg_unsupported< S, T, S, false, true >

struct Eigen::internal::promote_scalar_arg_unsupported< S, T, S, false, true >

template<typename S, typename T>
struct Eigen::internal::promote_scalar_arg_unsupported< S, T, S, false, true >

Eigen::internal::promote_storage_type

struct Eigen::internal::promote_storage_type

template<typename A, typename B>
struct Eigen::internal::promote_storage_type< A, B >

Eigen::internal::promote_storage_type< A, A >

struct Eigen::internal::promote_storage_type< A, A >

template<typename A>
struct Eigen::internal::promote_storage_type< A, A >

Class Members
typedef A	ret

Eigen::internal::promote_storage_type< A, const A >

struct Eigen::internal::promote_storage_type< A, const A >

template<typename A>
struct Eigen::internal::promote_storage_type< A, const A >

Class Members
typedef A	ret

Eigen::internal::promote_storage_type< const A, A >

struct Eigen::internal::promote_storage_type< const A, A >

template<typename A>
struct Eigen::internal::promote_storage_type< const A, A >

Class Members
typedef A	ret

Eigen::internal::qr_preconditioner_impl

struct Eigen::internal::qr_preconditioner_impl

template<typename MatrixType, int QRPreconditioner, int Case, bool DoAnything = qr_preconditioner_should_do_anything<MatrixType, QRPreconditioner, Case>::ret>
struct Eigen::internal::qr_preconditioner_impl< MatrixType, QRPreconditioner, Case, DoAnything >

Inheritance diagram for Eigen::internal::qr_preconditioner_impl< MatrixType, QRPreconditioner, Case, DoAnything >:

Eigen::internal::quaternionbase_assign_impl

struct Eigen::internal::quaternionbase_assign_impl

template<typename Other, int OtherRows = Other::RowsAtCompileTime, int OtherCols = Other::ColsAtCompileTime>
struct Eigen::internal::quaternionbase_assign_impl< Other, OtherRows, OtherCols >

Eigen::internal::random_default_impl

struct Eigen::internal::random_default_impl

template<typename Scalar, bool IsComplex, bool IsInteger>
struct Eigen::internal::random_default_impl< Scalar, IsComplex, IsInteger >

Inheritance diagram for Eigen::internal::random_default_impl< Scalar, IsComplex, IsInteger >:

Eigen::internal::random_retval

struct Eigen::internal::random_retval

template<typename Scalar>
struct Eigen::internal::random_retval< Scalar >

Class Members
typedef Scalar	type

Eigen::internal::real_ref_retval

struct Eigen::internal::real_ref_retval

template<typename Scalar>
struct Eigen::internal::real_ref_retval< Scalar >

Class Members
typedef Real &	type

Eigen::internal::real_retval

struct Eigen::internal::real_retval

template<typename Scalar>
struct Eigen::internal::real_retval< Scalar >

Class Members
typedef Real	type

Eigen::internal::redux_impl

struct Eigen::internal::redux_impl

template<typename Func, typename Derived, int Traversal = redux_traits<Func, Derived>::Traversal, int Unrolling = redux_traits<Func, Derived>::Unrolling>
struct Eigen::internal::redux_impl< Func, Derived, Traversal, Unrolling >

Eigen::internal::ref_selector

struct Eigen::internal::ref_selector

template<typename T>
struct Eigen::internal::ref_selector< T >

Inheritance diagram for Eigen::internal::ref_selector< T >:

Class Members
typedef Flags &NestByRefBit), T &, T >::type	non_const_type
typedef Flags &NestByRefBit), Tconst &, constT >::type	type

Eigen::internal::remove_all

struct Eigen::internal::remove_all

template<typename T>
struct Eigen::internal::remove_all< T >

Class Members
typedef T	type

Eigen::internal::remove_all< const T >

struct Eigen::internal::remove_all< const T >

template<typename T>
struct Eigen::internal::remove_all< const T >

Class Members
typedef type	type

Eigen::internal::remove_all< T & >

struct Eigen::internal::remove_all< T & >

template<typename T>
struct Eigen::internal::remove_all< T & >

Class Members
typedef type	type

Eigen::internal::remove_all< T * >

struct Eigen::internal::remove_all< T * >

template<typename T>
struct Eigen::internal::remove_all< T * >

Class Members
typedef type	type

Eigen::internal::remove_all< T const & >

struct Eigen::internal::remove_all< T const & >

template<typename T>
struct Eigen::internal::remove_all< T const & >

Class Members
typedef type	type

Eigen::internal::remove_all< T const * >

struct Eigen::internal::remove_all< T const * >

template<typename T>
struct Eigen::internal::remove_all< T const * >

Class Members
typedef type	type

Eigen::internal::remove_const

struct Eigen::internal::remove_const

template<class T>
struct Eigen::internal::remove_const< T >

Class Members
typedef T	type

Eigen::internal::remove_const< const T >

struct Eigen::internal::remove_const< const T >

template<class T>
struct Eigen::internal::remove_const< const T >

Class Members
typedef T	type

Eigen::internal::remove_const< const T[]>

struct Eigen::internal::remove_const< const T[]>

template<class T>
struct Eigen::internal::remove_const< const T[]>

Class Members
typedef T	type

Eigen::internal::remove_const< const T[Size]>

struct Eigen::internal::remove_const< const T[Size]>

template<class T, unsigned int Size>
struct Eigen::internal::remove_const< const T[Size]>

Class Members
typedef T	type

Eigen::internal::remove_pointer

struct Eigen::internal::remove_pointer

template<typename T>
struct Eigen::internal::remove_pointer< T >

Class Members
typedef T	type

Eigen::internal::remove_pointer< T * >

struct Eigen::internal::remove_pointer< T * >

template<typename T>
struct Eigen::internal::remove_pointer< T * >

Class Members
typedef T	type

Eigen::internal::remove_pointer< T *const >

struct Eigen::internal::remove_pointer< T *const >

template<typename T>
struct Eigen::internal::remove_pointer< T *const >

Class Members
typedef T	type

Eigen::internal::remove_reference

struct Eigen::internal::remove_reference

template<typename T>
struct Eigen::internal::remove_reference< T >

Class Members
typedef T	type

Eigen::internal::remove_reference< T & >

struct Eigen::internal::remove_reference< T & >

template<typename T>
struct Eigen::internal::remove_reference< T & >

Class Members
typedef T	type

Eigen::internal::result_of

struct Eigen::internal::result_of

template<typename T>
struct Eigen::internal::result_of< T >

Eigen::internal::result_of< scalar_cmp_op< LhsScalar, RhsScalar, Cmp >(LhsScalar, RhsScalar)>

struct Eigen::internal::result_of< scalar_cmp_op< LhsScalar, RhsScalar, Cmp >(LhsScalar, RhsScalar)>

template<ComparisonName Cmp, typename LhsScalar, typename RhsScalar>
struct Eigen::internal::result_of< scalar_cmp_op< LhsScalar, RhsScalar, Cmp >(LhsScalar, RhsScalar)>

Class Members
typedef bool	type

Eigen::internal::rotation_base_generic_product_selector

struct Eigen::internal::rotation_base_generic_product_selector

template<typename RotationDerived, typename MatrixType, bool IsVector = MatrixType::IsVectorAtCompileTime>
struct Eigen::internal::rotation_base_generic_product_selector< RotationDerived, MatrixType, IsVector >

Eigen::internal::round_retval

struct Eigen::internal::round_retval

template<typename Scalar>
struct Eigen::internal::round_retval< Scalar >

Class Members
typedef Scalar	type

Eigen::internal::scalar_betainc_op

struct Eigen::internal::scalar_betainc_op

template<typename Scalar>
struct Eigen::internal::scalar_betainc_op< Scalar >

Eigen::internal::scalar_cmp_op

struct Eigen::internal::scalar_cmp_op

template<typename LhsScalar, typename RhsScalar, ComparisonName cmp>
struct Eigen::internal::scalar_cmp_op< LhsScalar, RhsScalar, cmp >

Eigen::internal::scalar_digamma_op

struct Eigen::internal::scalar_digamma_op

template<typename Scalar>
struct Eigen::internal::scalar_digamma_op< Scalar >

Eigen::internal::scalar_erf_op

struct Eigen::internal::scalar_erf_op

template<typename Scalar>
struct Eigen::internal::scalar_erf_op< Scalar >

Eigen::internal::scalar_erfc_op

struct Eigen::internal::scalar_erfc_op

template<typename Scalar>
struct Eigen::internal::scalar_erfc_op< Scalar >

Eigen::internal::scalar_fuzzy_default_impl

struct Eigen::internal::scalar_fuzzy_default_impl

template<typename Scalar, bool IsComplex, bool IsInteger>
struct Eigen::internal::scalar_fuzzy_default_impl< Scalar, IsComplex, IsInteger >

Inheritance diagram for Eigen::internal::scalar_fuzzy_default_impl< Scalar, IsComplex, IsInteger >:

Eigen::internal::scalar_hypot_op

struct Eigen::internal::scalar_hypot_op

template<typename LhsScalar, typename RhsScalar = LhsScalar>
struct Eigen::internal::scalar_hypot_op< LhsScalar, RhsScalar >

Eigen::internal::scalar_igamma_op

struct Eigen::internal::scalar_igamma_op

template<typename Scalar>
struct Eigen::internal::scalar_igamma_op< Scalar >

Eigen::internal::scalar_igammac_op

struct Eigen::internal::scalar_igammac_op

template<typename Scalar>
struct Eigen::internal::scalar_igammac_op< Scalar >

Eigen::internal::scalar_lgamma_op

struct Eigen::internal::scalar_lgamma_op

template<typename Scalar>
struct Eigen::internal::scalar_lgamma_op< Scalar >

Eigen::internal::scalar_sign_op

struct Eigen::internal::scalar_sign_op

template<typename Scalar, bool iscpx = (NumTraits<Scalar>::IsComplex!=0)>
struct Eigen::internal::scalar_sign_op< Scalar, iscpx >

Eigen::internal::scalar_zeta_op

struct Eigen::internal::scalar_zeta_op

template<typename Scalar>
struct Eigen::internal::scalar_zeta_op< Scalar >

Eigen::internal::Selector

struct Eigen::internal::Selector

template<size_t N>
struct Eigen::internal::Selector< N >

Class Members
bool	select[N]

Eigen::internal::selfadjoint_product_impl

struct Eigen::internal::selfadjoint_product_impl

template<typename Lhs, int LhsMode, bool LhsIsVector, typename Rhs, int RhsMode, bool RhsIsVector>
struct Eigen::internal::selfadjoint_product_impl< Lhs, LhsMode, LhsIsVector, Rhs, RhsMode, RhsIsVector >

Eigen::internal::selfadjoint_rank2_update_selector

struct Eigen::internal::selfadjoint_rank2_update_selector

template<typename Scalar, typename Index, typename UType, typename VType, int UpLo>
struct Eigen::internal::selfadjoint_rank2_update_selector< Scalar, Index, UType, VType, UpLo >

Eigen::internal::smart_copy_helper

struct Eigen::internal::smart_copy_helper

template<typename T, bool UseMemcpy>
struct Eigen::internal::smart_copy_helper< T, UseMemcpy >

Eigen::internal::smart_memmove_helper

struct Eigen::internal::smart_memmove_helper

template<typename T, bool UseMemmove>
struct Eigen::internal::smart_memmove_helper< T, UseMemmove >

Eigen::internal::solve_traits

struct Eigen::internal::solve_traits

template<typename Decomposition, typename RhsType, typename StorageKind>
struct Eigen::internal::solve_traits< Decomposition, RhsType, StorageKind >

Eigen::internal::solve_traits< Decomposition, RhsType, Dense >

struct Eigen::internal::solve_traits< Decomposition, RhsType, Dense >

template<typename Decomposition, typename RhsType>
struct Eigen::internal::solve_traits< Decomposition, RhsType, Dense >

Class Members
typedef type	PlainObject

Eigen::internal::solve_traits< Decomposition, RhsType, Sparse >

struct Eigen::internal::solve_traits< Decomposition, RhsType, Sparse >

template<typename Decomposition, typename RhsType>
struct Eigen::internal::solve_traits< Decomposition, RhsType, Sparse >

Class Members
typedef Flags >::type	PlainObject

Eigen::internal::Sparse2Dense

struct Eigen::internal::Sparse2Dense

Eigen::internal::Sparse2Sparse

struct Eigen::internal::Sparse2Sparse

Eigen::internal::sparse_conjunction_evaluator

struct Eigen::internal::sparse_conjunction_evaluator

template<typename T, typename LhsKind = typename evaluator_traits<typename T::Lhs>::Kind, typename RhsKind = typename evaluator_traits<typename T::Rhs>::Kind, typename LhsScalar = typename traits<typename T::Lhs>::Scalar, typename RhsScalar = typename traits<typename T::Rhs>::Scalar>
struct Eigen::internal::sparse_conjunction_evaluator< T, LhsKind, RhsKind, LhsScalar, RhsScalar >

Inheritance diagram for Eigen::internal::sparse_conjunction_evaluator< T, LhsKind, RhsKind, LhsScalar, RhsScalar >:

Eigen::internal::sparse_diagonal_product_evaluator

struct Eigen::internal::sparse_diagonal_product_evaluator

template<typename SparseXprType, typename DiagonalCoeffType, int SDP_Tag>
struct Eigen::internal::sparse_diagonal_product_evaluator< SparseXprType, DiagonalCoeffType, SDP_Tag >

Inheritance diagram for Eigen::internal::sparse_diagonal_product_evaluator< SparseXprType, DiagonalCoeffType, SDP_Tag >:

Eigen::internal::sparse_eval< T, 1, 1, Flags >

struct Eigen::internal::sparse_eval< T, 1, 1, Flags >

template<typename T, int Flags>
struct Eigen::internal::sparse_eval< T, 1, 1, Flags >

Class Members
typedef Scalar	_Scalar
typedef Matrix< _Scalar, 1, 1 >	type

Eigen::internal::sparse_eval< T, 1, Cols, Flags >

struct Eigen::internal::sparse_eval< T, 1, Cols, Flags >

template<typename T, int Cols, int Flags>
struct Eigen::internal::sparse_eval< T, 1, Cols, Flags >

Class Members
typedef Scalar	_Scalar
typedef StorageIndex	_StorageIndex
typedef SparseVector< _Scalar, RowMajor, _StorageIndex >	type

Eigen::internal::sparse_eval< T, Rows, 1, Flags >

struct Eigen::internal::sparse_eval< T, Rows, 1, Flags >

template<typename T, int Rows, int Flags>
struct Eigen::internal::sparse_eval< T, Rows, 1, Flags >

Class Members
typedef Scalar	_Scalar
typedef StorageIndex	_StorageIndex
typedef SparseVector< _Scalar, ColMajor, _StorageIndex >	type

Eigen::internal::sparse_solve_triangular_selector

struct Eigen::internal::sparse_solve_triangular_selector

template<typename Lhs, typename Rhs, int Mode, int UpLo = (Mode & Lower) ? Lower : (Mode & Upper) ? Upper : -1, int StorageOrder = int(traits<Lhs>::Flags) & RowMajorBit>
struct Eigen::internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, UpLo, StorageOrder >

Eigen::internal::sparse_solve_triangular_sparse_selector

struct Eigen::internal::sparse_solve_triangular_sparse_selector

template<typename Lhs, typename Rhs, int Mode, int UpLo = (Mode & Lower) ? Lower : (Mode & Upper) ? Upper : -1, int StorageOrder = int(Lhs::Flags) & (RowMajorBit)>
struct Eigen::internal::sparse_solve_triangular_sparse_selector< Lhs, Rhs, Mode, UpLo, StorageOrder >

Eigen::internal::sparse_sparse_product_with_pruning_selector

struct Eigen::internal::sparse_sparse_product_with_pruning_selector

template<typename Lhs, typename Rhs, typename ResultType, int LhsStorageOrder = traits<Lhs>::Flags&RowMajorBit, int RhsStorageOrder = traits<Rhs>::Flags&RowMajorBit, int ResStorageOrder = traits<ResultType>::Flags&RowMajorBit>
struct Eigen::internal::sparse_sparse_product_with_pruning_selector< Lhs, Rhs, ResultType, LhsStorageOrder, RhsStorageOrder, ResStorageOrder >

Eigen::internal::sparse_sparse_to_dense_product_selector

struct Eigen::internal::sparse_sparse_to_dense_product_selector

template<typename Lhs, typename Rhs, typename ResultType, int LhsStorageOrder = (traits<Lhs>::Flags&RowMajorBit) ? RowMajor : ColMajor, int RhsStorageOrder = (traits<Rhs>::Flags&RowMajorBit) ? RowMajor : ColMajor>
struct Eigen::internal::sparse_sparse_to_dense_product_selector< Lhs, Rhs, ResultType, LhsStorageOrder, RhsStorageOrder >

Eigen::internal::sparse_time_dense_product_impl

struct Eigen::internal::sparse_time_dense_product_impl

template<typename SparseLhsType, typename DenseRhsType, typename DenseResType, typename AlphaType, int LhsStorageOrder = ((SparseLhsType::Flags&RowMajorBit)==RowMajorBit) ? RowMajor : ColMajor, bool ColPerCol = ((DenseRhsType::Flags&RowMajorBit)==0) || DenseRhsType::ColsAtCompileTime==1>
struct Eigen::internal::sparse_time_dense_product_impl< SparseLhsType, DenseRhsType, DenseResType, AlphaType, LhsStorageOrder, ColPerCol >

Eigen::internal::sparse_vector_assign_selector

struct Eigen::internal::sparse_vector_assign_selector

template<typename Dest, typename Src, int AssignmentKind = !bool(Src::IsVectorAtCompileTime) ? SVA_RuntimeSwitch : Src::InnerSizeAtCompileTime==1 ? SVA_Outer : SVA_Inner>
struct Eigen::internal::sparse_vector_assign_selector< Dest, Src, AssignmentKind >

Eigen::internal::SparseSelfAdjoint2Sparse

struct Eigen::internal::SparseSelfAdjoint2Sparse

Eigen::internal::static_assertion

struct Eigen::internal::static_assertion

template<bool condition>
struct Eigen::internal::static_assertion< condition >

Eigen::internal::stem_function

struct Eigen::internal::stem_function

template<typename Scalar>
struct Eigen::internal::stem_function< Scalar >

Class Members
typedef Real >	ComplexScalar
typedef ComplexScalar	type

Eigen::internal::storage_kind_to_evaluator_kind

struct Eigen::internal::storage_kind_to_evaluator_kind

template<typename StorageKind>
struct Eigen::internal::storage_kind_to_evaluator_kind< StorageKind >

Class Members
typedef IndexBased	Kind

Eigen::internal::storage_kind_to_evaluator_kind< Sparse >

struct Eigen::internal::storage_kind_to_evaluator_kind< Sparse >

Class Members
typedef IteratorBased	Kind

Eigen::internal::storage_kind_to_shape

struct Eigen::internal::storage_kind_to_shape

template<typename StorageKind>
struct Eigen::internal::storage_kind_to_shape< StorageKind >

Eigen::internal::storage_kind_to_shape< Dense >

struct Eigen::internal::storage_kind_to_shape< Dense >

Class Members
typedef DenseShape	Shape

Eigen::internal::storage_kind_to_shape< DiagonalShape >

struct Eigen::internal::storage_kind_to_shape< DiagonalShape >

Class Members
typedef DiagonalShape	Shape

Eigen::internal::storage_kind_to_shape< PermutationStorage >

struct Eigen::internal::storage_kind_to_shape< PermutationStorage >

Class Members
typedef PermutationShape	Shape

Eigen::internal::storage_kind_to_shape< SolverStorage >

struct Eigen::internal::storage_kind_to_shape< SolverStorage >

Class Members
typedef SolverShape	Shape

Eigen::internal::storage_kind_to_shape< Sparse >

struct Eigen::internal::storage_kind_to_shape< Sparse >

Class Members
typedef SparseShape	Shape

Eigen::internal::storage_kind_to_shape< TranspositionsStorage >

struct Eigen::internal::storage_kind_to_shape< TranspositionsStorage >

Class Members
typedef TranspositionsShape	Shape

Eigen::internal::svd_precondition_2x2_block_to_be_real

struct Eigen::internal::svd_precondition_2x2_block_to_be_real

template<typename MatrixType, int QRPreconditioner, bool IsComplex = NumTraits<typename MatrixType::Scalar>::IsComplex>
struct Eigen::internal::svd_precondition_2x2_block_to_be_real< MatrixType, QRPreconditioner, IsComplex >

Eigen::internal::ternary_evaluator

struct Eigen::internal::ternary_evaluator

template<typename T, typename Arg1Kind = typename evaluator_traits<typename T::Arg1>::Kind, typename Arg2Kind = typename evaluator_traits<typename T::Arg2>::Kind, typename Arg3Kind = typename evaluator_traits<typename T::Arg3>::Kind, typename Arg1Scalar = typename traits<typename T::Arg1>::Scalar, typename Arg2Scalar = typename traits<typename T::Arg2>::Scalar, typename Arg3Scalar = typename traits<typename T::Arg3>::Scalar>
struct Eigen::internal::ternary_evaluator< T, Arg1Kind, Arg2Kind, Arg3Kind, Arg1Scalar, Arg2Scalar, Arg3Scalar >

Inheritance diagram for Eigen::internal::ternary_evaluator< T, Arg1Kind, Arg2Kind, Arg3Kind, Arg1Scalar, Arg2Scalar, Arg3Scalar >:

Eigen::internal::ternary_result_of_select

struct Eigen::internal::ternary_result_of_select

template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2, int SizeOf = sizeof(has_none)>
struct Eigen::internal::ternary_result_of_select< Func, ArgType0, ArgType1, ArgType2, SizeOf >

Class Members
typedef type	type

Eigen::internal::ternary_result_of_select< Func, ArgType0, ArgType1, ArgType2, sizeof(has_std_result_type)>

struct Eigen::internal::ternary_result_of_select< Func, ArgType0, ArgType1, ArgType2, sizeof(has_std_result_type)>

template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2>
struct Eigen::internal::ternary_result_of_select< Func, ArgType0, ArgType1, ArgType2, sizeof(has_std_result_type)>

Class Members
typedef result_type	type

Eigen::internal::ternary_result_of_select< Func, ArgType0, ArgType1, ArgType2, sizeof(has_tr1_result)>

struct Eigen::internal::ternary_result_of_select< Func, ArgType0, ArgType1, ArgType2, sizeof(has_tr1_result)>

template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2>
struct Eigen::internal::ternary_result_of_select< Func, ArgType0, ArgType1, ArgType2, sizeof(has_tr1_result)>

Class Members
typedef template type	type

Eigen::internal::traits< AngleAxis< _Scalar > >

struct Eigen::internal::traits< AngleAxis< _Scalar > >

template<typename _Scalar>
struct Eigen::internal::traits< AngleAxis< _Scalar > >

Class Members
typedef _Scalar	Scalar

Eigen::internal::traits< BDCSVD< _MatrixType > >

struct Eigen::internal::traits< BDCSVD< _MatrixType > >

template<typename _MatrixType>
struct Eigen::internal::traits< BDCSVD< _MatrixType > >

Class Members
typedef _MatrixType	MatrixType

Eigen::internal::traits< BiCGSTAB< _MatrixType, _Preconditioner > >

struct Eigen::internal::traits< BiCGSTAB< _MatrixType, _Preconditioner > >

template<typename _MatrixType, typename _Preconditioner>
struct Eigen::internal::traits< BiCGSTAB< _MatrixType, _Preconditioner > >

Class Members
typedef _MatrixType	MatrixType
typedef _Preconditioner	Preconditioner

Eigen::internal::traits< BlockSparseMatrixView< BlockSparseMatrixT > >

struct Eigen::internal::traits< BlockSparseMatrixView< BlockSparseMatrixT > >

template<typename BlockSparseMatrixT>
struct Eigen::internal::traits< BlockSparseMatrixView< BlockSparseMatrixT > >

Class Members
typedef Ref< Matrix< typename RealScalar, BlockSize, BlockSize > >	RealScalar
typedef Ref< Matrix< typename Scalar, BlockSize, BlockSize > >	Scalar

Eigen::internal::traits< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >

struct Eigen::internal::traits< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >

template<typename _MatrixType, int _UpLo, typename _Preconditioner>
struct Eigen::internal::traits< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >

Class Members
typedef _MatrixType	MatrixType
typedef _Preconditioner	Preconditioner

Eigen::internal::traits< FullPivHouseholderQRMatrixQReturnType< MatrixType > >

struct Eigen::internal::traits< FullPivHouseholderQRMatrixQReturnType< MatrixType > >

template<typename MatrixType>
struct Eigen::internal::traits< FullPivHouseholderQRMatrixQReturnType< MatrixType > >

Class Members
typedef PlainObject	ReturnType

Eigen::internal::traits< HessenbergDecompositionMatrixHReturnType< MatrixType > >

struct Eigen::internal::traits< HessenbergDecompositionMatrixHReturnType< MatrixType > >

template<typename MatrixType>
struct Eigen::internal::traits< HessenbergDecompositionMatrixHReturnType< MatrixType > >

Class Members
typedef MatrixType	ReturnType

Eigen::internal::traits< homogeneous_left_product_impl< Homogeneous< MatrixType, Vertical >, Lhs > >

struct Eigen::internal::traits< homogeneous_left_product_impl< Homogeneous< MatrixType, Vertical >, Lhs > >

template<typename MatrixType, typename Lhs>
struct Eigen::internal::traits< homogeneous_left_product_impl< Homogeneous< MatrixType, Vertical >, Lhs > >

Class Members
typedef type	LhsMatrixType
typedef type	LhsMatrixTypeCleaned
typedef type	MatrixTypeCleaned
typedef Scalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime >::type	ReturnType

Eigen::internal::traits< homogeneous_right_product_impl< Homogeneous< MatrixType, Horizontal >, Rhs > >

struct Eigen::internal::traits< homogeneous_right_product_impl< Homogeneous< MatrixType, Horizontal >, Rhs > >

template<typename MatrixType, typename Rhs>
struct Eigen::internal::traits< homogeneous_right_product_impl< Homogeneous< MatrixType, Horizontal >, Rhs > >

Class Members
typedef Scalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime >::type	ReturnType

Eigen::internal::traits< image_retval_base< DecompositionType > >

struct Eigen::internal::traits< image_retval_base< DecompositionType > >

template<typename DecompositionType>
struct Eigen::internal::traits< image_retval_base< DecompositionType > >

Class Members
typedef MatrixType	MatrixType
typedef Matrix< typename Scalar, RowsAtCompileTime, Dynamic, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime >	ReturnType

Eigen::internal::traits< JacobiSVD< _MatrixType, QRPreconditioner > >

struct Eigen::internal::traits< JacobiSVD< _MatrixType, QRPreconditioner > >

template<typename _MatrixType, int QRPreconditioner>
struct Eigen::internal::traits< JacobiSVD< _MatrixType, QRPreconditioner > >

Class Members
typedef _MatrixType	MatrixType

Eigen::internal::traits< kernel_retval_base< DecompositionType > >

struct Eigen::internal::traits< kernel_retval_base< DecompositionType > >

template<typename DecompositionType>
struct Eigen::internal::traits< kernel_retval_base< DecompositionType > >

Class Members
typedef MatrixType	MatrixType
typedef Matrix< typename Scalar, ColsAtCompileTime, Dynamic, Options, MaxColsAtCompileTime, MaxColsAtCompileTime >	ReturnType

Eigen::internal::traits< LeastSquaresConjugateGradient< _MatrixType, _Preconditioner > >

struct Eigen::internal::traits< LeastSquaresConjugateGradient< _MatrixType, _Preconditioner > >

template<typename _MatrixType, typename _Preconditioner>
struct Eigen::internal::traits< LeastSquaresConjugateGradient< _MatrixType, _Preconditioner > >

Class Members
typedef _MatrixType	MatrixType
typedef _Preconditioner	Preconditioner

Eigen::internal::traits< Rotation2D< _Scalar > >

struct Eigen::internal::traits< Rotation2D< _Scalar > >

template<typename _Scalar>
struct Eigen::internal::traits< Rotation2D< _Scalar > >

Class Members
typedef _Scalar	Scalar

Eigen::internal::traits< SparseQR_QProduct< SparseQRType, Derived > >

struct Eigen::internal::traits< SparseQR_QProduct< SparseQRType, Derived > >

template<typename SparseQRType, typename Derived>
struct Eigen::internal::traits< SparseQR_QProduct< SparseQRType, Derived > >

Class Members
typedef PlainObject	ReturnType

Eigen::internal::traits< SparseQRMatrixQTransposeReturnType< SparseQRType > >

struct Eigen::internal::traits< SparseQRMatrixQTransposeReturnType< SparseQRType > >

template<typename SparseQRType>
struct Eigen::internal::traits< SparseQRMatrixQTransposeReturnType< SparseQRType > >

Class Members
typedef MatrixType	ReturnType

Eigen::internal::traits< SPQR_QProduct< SPQRType, Derived > >

struct Eigen::internal::traits< SPQR_QProduct< SPQRType, Derived > >

template<typename SPQRType, typename Derived>
struct Eigen::internal::traits< SPQR_QProduct< SPQRType, Derived > >

Class Members
typedef PlainObject	ReturnType

Eigen::internal::traits< SPQRMatrixQReturnType< SPQRType > >

struct Eigen::internal::traits< SPQRMatrixQReturnType< SPQRType > >

template<typename SPQRType>
struct Eigen::internal::traits< SPQRMatrixQReturnType< SPQRType > >

Class Members
typedef MatrixType	ReturnType

Eigen::internal::traits< SPQRMatrixQTransposeReturnType< SPQRType > >

struct Eigen::internal::traits< SPQRMatrixQTransposeReturnType< SPQRType > >

template<typename SPQRType>
struct Eigen::internal::traits< SPQRMatrixQTransposeReturnType< SPQRType > >

Class Members
typedef MatrixType	ReturnType

Eigen::internal::traits< triangular_solve_retval< Side, TriangularType, Rhs > >

struct Eigen::internal::traits< triangular_solve_retval< Side, TriangularType, Rhs > >

template<int Side, typename TriangularType, typename Rhs>
struct Eigen::internal::traits< triangular_solve_retval< Side, TriangularType, Rhs > >

Class Members
typedef type	ReturnType

Eigen::internal::transfer_constness

struct Eigen::internal::transfer_constness

template<typename T1, typename T2>
struct Eigen::internal::transfer_constness< T1, T2 >

Class Members
typedef value), type, T2 >::type	type

Eigen::internal::transform_construct_from_matrix

struct Eigen::internal::transform_construct_from_matrix

template<typename Other, int Mode, int Options, int Dim, int HDim, int OtherRows = Other::RowsAtCompileTime, int OtherCols = Other::ColsAtCompileTime>
struct Eigen::internal::transform_construct_from_matrix< Other, Mode, Options, Dim, HDim, OtherRows, OtherCols >

Eigen::internal::transform_left_product_impl

struct Eigen::internal::transform_left_product_impl

template<typename Other, int Mode, int Options, int Dim, int HDim, int OtherRows = Other::RowsAtCompileTime, int OtherCols = Other::ColsAtCompileTime>
struct Eigen::internal::transform_left_product_impl< Other, Mode, Options, Dim, HDim, OtherRows, OtherCols >

Eigen::internal::transform_right_product_impl

struct Eigen::internal::transform_right_product_impl

template<typename TransformType, typename MatrixType, int Case = transform_traits<TransformType>::IsProjective ? 0 : int(MatrixType::RowsAtCompileTime) == int(transform_traits<TransformType>::HDim) ? 1 : 2, int RhsCols = MatrixType::ColsAtCompileTime>
struct Eigen::internal::transform_right_product_impl< TransformType, MatrixType, Case, RhsCols >

Eigen::internal::transform_transform_product_impl

struct Eigen::internal::transform_transform_product_impl

template<typename Lhs, typename Rhs, bool AnyProjective = transform_traits<Lhs>::IsProjective || transform_traits<Rhs>::IsProjective>
struct Eigen::internal::transform_transform_product_impl< Lhs, Rhs, AnyProjective >

Eigen::internal::TransposeImpl_base

struct Eigen::internal::TransposeImpl_base

template<typename MatrixType, bool HasDirectAccess = has_direct_access<MatrixType>::ret>
struct Eigen::internal::TransposeImpl_base< MatrixType, HasDirectAccess >

Class Members
typedef dense_xpr_base< Transpose< MatrixType > >::type	type

Eigen::internal::TransposeImpl_base< MatrixType, false >

struct Eigen::internal::TransposeImpl_base< MatrixType, false >

template<typename MatrixType>
struct Eigen::internal::TransposeImpl_base< MatrixType, false >

Class Members
typedef dense_xpr_base< Transpose< MatrixType > >::type	type

Eigen::internal::Triangular2Dense

struct Eigen::internal::Triangular2Dense

Eigen::internal::Triangular2Triangular

struct Eigen::internal::Triangular2Triangular

Eigen::internal::triangular_matrix_vector_product

struct Eigen::internal::triangular_matrix_vector_product

template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int StorageOrder, int Version = Specialized>
struct Eigen::internal::triangular_matrix_vector_product< Index, Mode, LhsScalar, ConjLhs, RhsScalar, ConjRhs, StorageOrder, Version >

Inheritance diagram for Eigen::internal::triangular_matrix_vector_product< Index, Mode, LhsScalar, ConjLhs, RhsScalar, ConjRhs, StorageOrder, Version >:

Eigen::internal::triangular_product_impl

struct Eigen::internal::triangular_product_impl

template<int Mode, bool LhsIsTriangular, typename Lhs, bool LhsIsVector, typename Rhs, bool RhsIsVector>
struct Eigen::internal::triangular_product_impl< Mode, LhsIsTriangular, Lhs, LhsIsVector, Rhs, RhsIsVector >

Eigen::internal::triangular_solve_matrix

struct Eigen::internal::triangular_solve_matrix

template<typename Scalar, typename Index, int Side, int Mode, bool Conjugate, int TriStorageOrder, int OtherStorageOrder>
struct Eigen::internal::triangular_solve_matrix< Scalar, Index, Side, Mode, Conjugate, TriStorageOrder, OtherStorageOrder >

Eigen::internal::triangular_solve_vector

struct Eigen::internal::triangular_solve_vector

template<typename LhsScalar, typename RhsScalar, typename Index, int Side, int Mode, bool Conjugate, int StorageOrder>
struct Eigen::internal::triangular_solve_vector< LhsScalar, RhsScalar, Index, Side, Mode, Conjugate, StorageOrder >

Eigen::internal::triangular_solver_selector

struct Eigen::internal::triangular_solver_selector

template<typename Lhs, typename Rhs, int Side, int Mode, int Unrolling = trsolve_traits<Lhs,Rhs,Side>::Unrolling, int RhsVectors = trsolve_traits<Lhs,Rhs,Side>::RhsVectors>
struct Eigen::internal::triangular_solver_selector< Lhs, Rhs, Side, Mode, Unrolling, RhsVectors >

Eigen::internal::triangular_solver_unroller

struct Eigen::internal::triangular_solver_unroller

template<typename Lhs, typename Rhs, int Mode, int LoopIndex, int Size, bool Stop = LoopIndex==Size>
struct Eigen::internal::triangular_solver_unroller< Lhs, Rhs, Mode, LoopIndex, Size, Stop >

Eigen::internal::trmv_selector

struct Eigen::internal::trmv_selector

template<int Mode, int StorageOrder>
struct Eigen::internal::trmv_selector< Mode, StorageOrder >

Eigen::internal::unary_result_of_select

struct Eigen::internal::unary_result_of_select

template<typename Func, typename ArgType, int SizeOf = sizeof(has_none)>
struct Eigen::internal::unary_result_of_select< Func, ArgType, SizeOf >

Class Members
typedef type	type

Eigen::internal::unary_result_of_select< Func, ArgType, sizeof(has_std_result_type)>

struct Eigen::internal::unary_result_of_select< Func, ArgType, sizeof(has_std_result_type)>

template<typename Func, typename ArgType>
struct Eigen::internal::unary_result_of_select< Func, ArgType, sizeof(has_std_result_type)>

Class Members
typedef result_type	type

Eigen::internal::unary_result_of_select< Func, ArgType, sizeof(has_tr1_result)>

struct Eigen::internal::unary_result_of_select< Func, ArgType, sizeof(has_tr1_result)>

template<typename Func, typename ArgType>
struct Eigen::internal::unary_result_of_select< Func, ArgType, sizeof(has_tr1_result)>

Class Members
typedef template type	type

Eigen::internal::unpacket_traits< DoublePacket< Packet > >

struct Eigen::internal::unpacket_traits< DoublePacket< Packet > >

template<typename Packet>
struct Eigen::internal::unpacket_traits< DoublePacket< Packet > >

Class Members
typedef DoublePacket< Packet >	half

Eigen::internal::vectorwise_reverse_inplace_impl

struct Eigen::internal::vectorwise_reverse_inplace_impl

template<int Direction>
struct Eigen::internal::vectorwise_reverse_inplace_impl< Direction >

Typedef Documentation

IntPtr

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

Packet16f

typedef __m512 Eigen::internal::Packet16f

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

Packet2ul

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

Packet4bi

typedef __vector __bool int Eigen::internal::Packet4bi

Packet4d

typedef __m256d Eigen::internal::Packet4d

Packet4f

typedef __m128 Eigen::internal::Packet4f

Packet4i

typedef __vector int Eigen::internal::Packet4i

Packet4ui

typedef __vector unsigned int Eigen::internal::Packet4ui

Packet8d

typedef __m512d Eigen::internal::Packet8d

Packet8f

typedef __m256 Eigen::internal::Packet8f

Packet8i

typedef __vector short int Eigen::internal::Packet8i

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

     {
  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

     {
  SDP_AsScalarProduct,
  SDP_AsCwiseProduct
};

anonymous enum

anonymous enum

Enumerator
SVA_RuntimeSwitch
SVA_Inner
SVA_Outer

     {
  SVA_RuntimeSwitch,
  SVA_Inner,
  SVA_Outer
};

anonymous enum

anonymous enum

Enumerator
LUNoMarker

{ LUNoMarker = 3 };

anonymous enum

anonymous enum

Enumerator
emptyIdxLU

{emptyIdxLU = -1};

anonymous enum

anonymous enum

Enumerator
PreconditionIfMoreColsThanRows
PreconditionIfMoreRowsThanCols

{ PreconditionIfMoreColsThanRows, PreconditionIfMoreRowsThanCols };

ComparisonName

enum Eigen::internal::ComparisonName

Enumerator
cmp_EQ
cmp_LT
cmp_LE
cmp_UNORD
cmp_NEQ
cmp_GT
cmp_GE

                    {
  cmp_EQ = 0,
  cmp_LT = 1,
  cmp_LE = 2,
  cmp_UNORD = 3,
  cmp_NEQ = 4,
  cmp_GT = 5,
  cmp_GE = 6
};

MemType

enum Eigen::internal::MemType

Enumerator
LUSUP
UCOL
LSUB
USUB
LLVL
ULVL

{LUSUP, UCOL, LSUB, USUB, LLVL, ULVL} MemType; 

PermPermProduct_t

enum Eigen::internal::PermPermProduct_t

Enumerator
PermPermProduct

{PermPermProduct};

SignMatrix

enum Eigen::internal::SignMatrix

Enumerator
PositiveSemiDef
NegativeSemiDef
ZeroSign
Indefinite

{ PositiveSemiDef, NegativeSemiDef, ZeroSign, Indefinite };

Function Documentation

_EIGEN_DECLARE_CONST_FAST_Packet2d()

static Eigen::internal::_EIGEN_DECLARE_CONST_FAST_Packet2d ( ZERO  , 0    )

static

_EIGEN_DECLARE_CONST_FAST_Packet2l() [1/2]

static Eigen::internal::_EIGEN_DECLARE_CONST_FAST_Packet2l ( ONE  , 1    )

static

_EIGEN_DECLARE_CONST_FAST_Packet2l() [2/2]

static Eigen::internal::_EIGEN_DECLARE_CONST_FAST_Packet2l ( ZERO  , 0    )

static

_EIGEN_DECLARE_CONST_FAST_Packet4f()

static Eigen::internal::_EIGEN_DECLARE_CONST_FAST_Packet4f ( ZERO  , 0    )

static

_EIGEN_DECLARE_CONST_FAST_Packet4i() [1/5]

static Eigen::internal::_EIGEN_DECLARE_CONST_FAST_Packet4i ( MINUS1  , -  1  )

static

_EIGEN_DECLARE_CONST_FAST_Packet4i() [2/5]

static Eigen::internal::_EIGEN_DECLARE_CONST_FAST_Packet4i ( MINUS16  , -  16  )

static

_EIGEN_DECLARE_CONST_FAST_Packet4i() [3/5]

static Eigen::internal::_EIGEN_DECLARE_CONST_FAST_Packet4i ( ONE  , 1    )

static

_EIGEN_DECLARE_CONST_FAST_Packet4i() [4/5]

static Eigen::internal::_EIGEN_DECLARE_CONST_FAST_Packet4i ( ONE  , 1    )

static

_EIGEN_DECLARE_CONST_FAST_Packet4i() [5/5]

static Eigen::internal::_EIGEN_DECLARE_CONST_FAST_Packet4i ( ZERO  , 0    )

static

_EIGEN_DECLARE_CONST_Packet2d() [1/15]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet2d ( 1  , 1.  0  )

static

_EIGEN_DECLARE_CONST_Packet2d() [2/15]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet2d ( 2  , 2.  0  )

static

_EIGEN_DECLARE_CONST_Packet2d() [3/15]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet2d ( cephes_exp_C1  , 0.  693145751953125  )

static

_EIGEN_DECLARE_CONST_Packet2d() [4/15]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet2d ( cephes_exp_C2  , 1.42860682030941723212e-  6  )

static

_EIGEN_DECLARE_CONST_Packet2d() [5/15]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet2d ( cephes_exp_p0  , 1.26177193074810590878e-  4  )

static

_EIGEN_DECLARE_CONST_Packet2d() [6/15]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet2d ( cephes_exp_p1  , 3.02994407707441961300e-  2  )

static

_EIGEN_DECLARE_CONST_Packet2d() [7/15]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet2d ( cephes_exp_p2  , 9.99999999999999999910e-  1  )

static

_EIGEN_DECLARE_CONST_Packet2d() [8/15]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet2d ( cephes_exp_q0  , 3.00198505138664455042e-  6  )

static

_EIGEN_DECLARE_CONST_Packet2d() [9/15]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet2d ( cephes_exp_q1  , 2.52448340349684104192e-  3  )

static

_EIGEN_DECLARE_CONST_Packet2d() [10/15]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet2d ( cephes_exp_q2  , 2.27265548208155028766e-  1  )

static

_EIGEN_DECLARE_CONST_Packet2d() [11/15]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet2d ( cephes_exp_q3  , 2.  00000000000000000009e0  )

static

_EIGEN_DECLARE_CONST_Packet2d() [12/15]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet2d ( cephes_LOG2EF  , 1.  4426950408889634073599  )

static

_EIGEN_DECLARE_CONST_Packet2d() [13/15]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet2d ( exp_hi  , 709.  437  )

static

_EIGEN_DECLARE_CONST_Packet2d() [14/15]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet2d ( exp_lo  , -709.  436139303  )

static

_EIGEN_DECLARE_CONST_Packet2d() [15/15]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet2d ( half  , 0.  5  )

static

_EIGEN_DECLARE_CONST_Packet4f() [1/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( 1  , 1.  0f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [2/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_exp_C1  , 0.  693359375f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [3/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_exp_C2  , -2.12194440e-  4f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [4/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_exp_p0  , 1.9875691500E-  4f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [5/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_exp_p1  , 1.3981999507E-  3f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [6/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_exp_p2  , 8.3334519073E-  3f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [7/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_exp_p3  , 4.1665795894E-  2f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [8/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_exp_p4  , 1.6666665459E-  1f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [9/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_exp_p5  , 5.0000001201E-  1f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [10/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_LOG2EF  , 1.  44269504088896341f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [11/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_log_p0  , 7.0376836292E-  2f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [12/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_log_p1  , - 1.1514610310E-  1f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [13/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_log_p2  , 1.1676998740E-  1f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [14/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_log_p3  , - 1.2420140846E-  1f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [15/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_log_p4  , +1.4249322787E-  1f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [16/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_log_p5  , - 1.6668057665E-  1f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [17/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_log_p6  , +2.0000714765E-  1f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [18/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_log_p7  , - 2.4999993993E-  1f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [19/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_log_p8  , +3.3333331174E-  1f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [20/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_log_q1  , -2.12194440e-  4f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [21/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_log_q2  , 0.  693359375f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [22/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_SQRTHF  , 0.  707106781186547524f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [23/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( exp_hi  , 88.  3762626647950f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [24/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( exp_lo  , -88.  3762626647949f  )

static

_EIGEN_DECLARE_CONST_Packet4f() [25/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( half  , 0.  5f  )

static

_EIGEN_DECLARE_CONST_Packet4f_FROM_INT() [1/4]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f_FROM_INT ( inv_mant_mask  , ~  0x7f800000  )

static

_EIGEN_DECLARE_CONST_Packet4f_FROM_INT() [2/4]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f_FROM_INT ( min_norm_pos  , 0x00800000    )

static

_EIGEN_DECLARE_CONST_Packet4f_FROM_INT() [3/4]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f_FROM_INT ( minus_inf  , 0xff800000    )

static

_EIGEN_DECLARE_CONST_Packet4f_FROM_INT() [4/4]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f_FROM_INT ( minus_nan  , 0xffffffff    )

static

_EIGEN_DECLARE_CONST_Packet4i() [1/2]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4i ( 0x7f  , 0x7f    )

static

_EIGEN_DECLARE_CONST_Packet4i() [2/2]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4i ( 23  , 23    )

static

aligned_delete()

template<typename T >

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

inline

{
  destruct_elements_of_array<T>(ptr, size);
  aligned_free(ptr);
}

References aligned_free().

Referenced by Eigen::internal::gemm_blocking_space< StorageOrder, _LhsScalar, _RhsScalar, MaxRows, MaxCols, MaxDepth, KcFactor, false >::~gemm_blocking_space().

Here is the call graph for this function:

Here is the caller graph for this function:

aligned_free()

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

inline

{
  #if (EIGEN_DEFAULT_ALIGN_BYTES==0) || EIGEN_MALLOC_ALREADY_ALIGNED
    std::free(ptr);
  #else
    handmade_aligned_free(ptr);
  #endif
}

References handmade_aligned_free().

Referenced by Eigen::internal::aligned_stack_memory_handler< T >::~aligned_stack_memory_handler(), aligned_delete(), aligned_new(), conditional_aligned_free(), and Eigen::aligned_allocator< T >::deallocate().

Here is the call graph for this function:

Here is the caller graph for this function:

aligned_malloc()

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

inline

{
  check_that_malloc_is_allowed();
 
  void *result;
  #if (EIGEN_DEFAULT_ALIGN_BYTES==0) || EIGEN_MALLOC_ALREADY_ALIGNED
    result = std::malloc(size);
    #if EIGEN_DEFAULT_ALIGN_BYTES==16
    eigen_assert((size<16 || (std::size_t(result)%16)==0) && "System's malloc returned an unaligned pointer. Compile with EIGEN_MALLOC_ALREADY_ALIGNED=0 to fallback to handmade alignd memory allocator.");
    #endif
  #else
    result = handmade_aligned_malloc(size);
  #endif
 
  if(!result && size)
    throw_std_bad_alloc();
 
  return result;
}

References check_that_malloc_is_allowed(), eigen_assert, handmade_aligned_malloc(), and throw_std_bad_alloc().

Referenced by aligned_new(), Eigen::aligned_allocator< T >::allocate(), and conditional_aligned_malloc().

Here is the call graph for this function:

Here is the caller graph for this function:

aligned_new()

template<typename T >

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

inline

{
  check_size_for_overflow<T>(size);
  T *result = reinterpret_cast<T*>(aligned_malloc(sizeof(T)*size));
  EIGEN_TRY
  {
    return construct_elements_of_array(result, size);
  }
  EIGEN_CATCH(...)
  {
    aligned_free(result);
    EIGEN_THROW;
  }
  return result;
}

References aligned_free(), aligned_malloc(), construct_elements_of_array(), EIGEN_CATCH, EIGEN_THROW, and EIGEN_TRY.

Here is the call graph for this function:

aligned_realloc()

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

inline

{
  EIGEN_UNUSED_VARIABLE(old_size);
 
  void *result;
#if (EIGEN_DEFAULT_ALIGN_BYTES==0) || EIGEN_MALLOC_ALREADY_ALIGNED
  result = std::realloc(ptr,new_size);
#else
  result = handmade_aligned_realloc(ptr,new_size,old_size);
#endif
 
  if (!result && new_size)
    throw_std_bad_alloc();
 
  return result;
}

References EIGEN_UNUSED_VARIABLE, handmade_aligned_realloc(), and throw_std_bad_alloc().

Referenced by conditional_aligned_realloc().

Here is the call graph for this function:

Here is the caller graph for this function:

amd_flip()

template<typename T >

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

inline

{ return -i-2; }

Referenced by amd_mark(), amd_unflip(), and minimum_degree_ordering().

Here is the caller graph for this function:

amd_mark()

template<typename T0 , typename T1 >

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

inline

{ return w[j] = amd_flip(w[j]); }

References amd_flip().

Here is the call graph for this function:

amd_marked()

template<typename T0 , typename T1 >

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

inline

{ return w[j]<0; }

amd_unflip()

template<typename T >

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

inline

{ return i<0 ? amd_flip(i) : i; }

References amd_flip().

Here is the call graph for this function:

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
	)

{
  enum { TFactorSize = MatrixType::ColsAtCompileTime };
  Index nbVecs = vectors.cols();
  Matrix<typename MatrixType::Scalar, TFactorSize, TFactorSize, RowMajor> T(nbVecs,nbVecs);
  
  if(forward) make_block_householder_triangular_factor(T, vectors, hCoeffs);
  else        make_block_householder_triangular_factor(T, vectors, hCoeffs.conjugate());  
  const TriangularView<const VectorsType, UnitLower> V(vectors);
 
  // A -= V T V^* A
  Matrix<typename MatrixType::Scalar,VectorsType::ColsAtCompileTime,MatrixType::ColsAtCompileTime,
         (VectorsType::MaxColsAtCompileTime==1 && MatrixType::MaxColsAtCompileTime!=1)?RowMajor:ColMajor,
         VectorsType::MaxColsAtCompileTime,MatrixType::MaxColsAtCompileTime> tmp = V.adjoint() * mat;
  // FIXME add .noalias() once the triangular product can work inplace
  if(forward) tmp = T.template triangularView<Upper>()           * tmp;
  else        tmp = T.template triangularView<Upper>().adjoint() * tmp;
  mat.noalias() -= V * tmp;
}

References Eigen::TriangularView< _MatrixType, _Mode >::adjoint(), Eigen::ColMajor, make_block_householder_triangular_factor(), and Eigen::RowMajor.

Referenced by Eigen::internal::householder_qr_inplace_blocked< MatrixQR, HCoeffs, MatrixQRScalar, InnerStrideIsOne >::run().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_rotation_in_the_plane()

template<typename VectorX , typename VectorY , typename OtherScalar >

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

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

See also

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

{
  typedef typename VectorX::Scalar Scalar;
  const bool Vectorizable =    (VectorX::Flags & VectorY::Flags & PacketAccessBit)
                            && (int(packet_traits<Scalar>::size) == int(packet_traits<OtherScalar>::size));
 
  eigen_assert(xpr_x.size() == xpr_y.size());
  Index size = xpr_x.size();
  Index incrx = xpr_x.derived().innerStride();
  Index incry = xpr_y.derived().innerStride();
 
  Scalar* EIGEN_RESTRICT x = &xpr_x.derived().coeffRef(0);
  Scalar* EIGEN_RESTRICT y = &xpr_y.derived().coeffRef(0);
  
  OtherScalar c = j.c();
  OtherScalar s = j.s();
  if (c==OtherScalar(1) && s==OtherScalar(0))
    return;
 
  apply_rotation_in_the_plane_selector<
    Scalar,OtherScalar,
    VectorX::SizeAtCompileTime,
    EIGEN_PLAIN_ENUM_MIN(evaluator<VectorX>::Alignment, evaluator<VectorY>::Alignment),
    Vectorizable>::run(x,incrx,y,incry,size,c,s);
}

Referenced by Eigen::MatrixBase< Derived >::applyOnTheLeft(), Eigen::MatrixBase< Derived >::applyOnTheRight(), and llt_rank_update_lower().

Here is the caller graph for this function:

assert_fail()

void Eigen::internal::assert_fail ( const char *  condition, const char *  function, const char *  file, int  line  )

inline

    {
      std::cerr << "assertion failed: " << condition << " in function " << function << " at " << file << ":" << line << std::endl;
      abort();
    }

assign_sparse_to_sparse()

template<typename DstXprType , typename SrcXprType >

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

{
  typedef typename DstXprType::Scalar Scalar;
  typedef internal::evaluator<DstXprType> DstEvaluatorType;
  typedef internal::evaluator<SrcXprType> SrcEvaluatorType;
 
  SrcEvaluatorType srcEvaluator(src);
 
  const bool transpose = (DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit);
  const Index outerEvaluationSize = (SrcEvaluatorType::Flags&RowMajorBit) ? src.rows() : src.cols();
  if ((!transpose) && src.isRValue())
  {
    // eval without temporary
    dst.resize(src.rows(), src.cols());
    dst.setZero();
    dst.reserve((std::max)(src.rows(),src.cols())*2);
    for (Index j=0; j<outerEvaluationSize; ++j)
    {
      dst.startVec(j);
      for (typename SrcEvaluatorType::InnerIterator it(srcEvaluator, j); it; ++it)
      {
        Scalar v = it.value();
        dst.insertBackByOuterInner(j,it.index()) = v;
      }
    }
    dst.finalize();
  }
  else
  {
    // eval through a temporary
    eigen_assert(( ((internal::traits<DstXprType>::SupportedAccessPatterns & OuterRandomAccessPattern)==OuterRandomAccessPattern) ||
              (!((DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit)))) &&
              "the transpose operation is supposed to be handled in SparseMatrix::operator=");
 
    enum { Flip = (DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit) };
 
    
    DstXprType temp(src.rows(), src.cols());
 
    temp.reserve((std::max)(src.rows(),src.cols())*2);
    for (Index j=0; j<outerEvaluationSize; ++j)
    {
      temp.startVec(j);
      for (typename SrcEvaluatorType::InnerIterator it(srcEvaluator, j); it; ++it)
      {
        Scalar v = it.value();
        temp.insertBackByOuterInner(Flip?it.index():j,Flip?j:it.index()) = v;
      }
    }
    temp.finalize();
 
    dst = temp.markAsRValue();
  }
}

References eigen_assert, Eigen::OuterRandomAccessPattern, and Eigen::RowMajorBit.

Referenced by Eigen::internal::Assignment< DstXprType, SrcXprType, Functor, Sparse2Sparse >::run().

Here is the caller graph for this function:

asSluMatrix()

template<typename MatrixType >

SluMatrix Eigen::internal::asSluMatrix

(

MatrixType &

mat

)

{
  return SluMatrix::Map(mat);
}

References Eigen::SluMatrix::Map().

Referenced by Eigen::SuperLUBase< _MatrixType, Derived >::initFactorization().

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

{
  using std::sqrt;
  using std::abs;
  typedef typename Dest::RealScalar RealScalar;
  typedef typename Dest::Scalar Scalar;
  typedef Matrix<Scalar,Dynamic,1> VectorType;
  RealScalar tol = tol_error;
  Index maxIters = iters;
 
  Index n = mat.cols();
  VectorType r  = rhs - mat * x;
  VectorType r0 = r;
  
  RealScalar r0_sqnorm = r0.squaredNorm();
  RealScalar rhs_sqnorm = rhs.squaredNorm();
  if(rhs_sqnorm == 0)
  {
    x.setZero();
    return true;
  }
  Scalar rho    = 1;
  Scalar alpha  = 1;
  Scalar w      = 1;
  
  VectorType v = VectorType::Zero(n), p = VectorType::Zero(n);
  VectorType y(n),  z(n);
  VectorType kt(n), ks(n);
 
  VectorType s(n), t(n);
 
  RealScalar tol2 = tol*tol*rhs_sqnorm;
  RealScalar eps2 = NumTraits<Scalar>::epsilon()*NumTraits<Scalar>::epsilon();
  Index i = 0;
  Index restarts = 0;
 
  while ( r.squaredNorm() > tol2 && i<maxIters )
  {
    Scalar rho_old = rho;
 
    rho = r0.dot(r);
    if (abs(rho) < eps2*r0_sqnorm)
    {
      // The new residual vector became too orthogonal to the arbitrarily chosen direction r0
      // Let's restart with a new r0:
      r  = rhs - mat * x;
      r0 = r;
      rho = r0_sqnorm = r.squaredNorm();
      if(restarts++ == 0)
        i = 0;
    }
    Scalar beta = (rho/rho_old) * (alpha / w);
    p = r + beta * (p - w * v);
    
    y = precond.solve(p);
    
    v.noalias() = mat * y;
 
    alpha = rho / r0.dot(v);
    s = r - alpha * v;
 
    z = precond.solve(s);
    t.noalias() = mat * z;
 
    RealScalar tmp = t.squaredNorm();
    if(tmp>RealScalar(0))
      w = t.dot(s) / tmp;
    else
      w = Scalar(0);
    x += alpha * y + w * z;
    r = s - w * t;
    ++i;
  }
  tol_error = sqrt(r.squaredNorm()/rhs_sqnorm);
  iters = i;
  return true; 
}

References Eigen::PlainObjectBase< Derived >::cols(), sqrt(), and y.

Referenced by Eigen::BiCGSTAB< _MatrixType, _Preconditioner >::_solve_with_guess_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

blueNorm_impl()

template<typename Derived >

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

inline

{
  typedef typename Derived::RealScalar RealScalar;  
  using std::pow;
  using std::sqrt;
  using std::abs;
  const Derived& vec(_vec.derived());
  static bool initialized = false;
  static RealScalar b1, b2, s1m, s2m, rbig, relerr;
  if(!initialized)
  {
    int ibeta, it, iemin, iemax, iexp;
    RealScalar eps;
    // This program calculates the machine-dependent constants
    // bl, b2, slm, s2m, relerr overfl
    // from the "basic" machine-dependent numbers
    // nbig, ibeta, it, iemin, iemax, rbig.
    // The following define the basic machine-dependent constants.
    // For portability, the PORT subprograms "ilmaeh" and "rlmach"
    // are used. For any specific computer, each of the assignment
    // statements can be replaced
    ibeta = std::numeric_limits<RealScalar>::radix;                 // base for floating-point numbers
    it    = std::numeric_limits<RealScalar>::digits;                // number of base-beta digits in mantissa
    iemin = std::numeric_limits<RealScalar>::min_exponent;          // minimum exponent
    iemax = std::numeric_limits<RealScalar>::max_exponent;          // maximum exponent
    rbig  = (std::numeric_limits<RealScalar>::max)();               // largest floating-point number
 
    iexp  = -((1-iemin)/2);
    b1    = RealScalar(pow(RealScalar(ibeta),RealScalar(iexp)));    // lower boundary of midrange
    iexp  = (iemax + 1 - it)/2;
    b2    = RealScalar(pow(RealScalar(ibeta),RealScalar(iexp)));    // upper boundary of midrange
 
    iexp  = (2-iemin)/2;
    s1m   = RealScalar(pow(RealScalar(ibeta),RealScalar(iexp)));    // scaling factor for lower range
    iexp  = - ((iemax+it)/2);
    s2m   = RealScalar(pow(RealScalar(ibeta),RealScalar(iexp)));    // scaling factor for upper range
 
    eps     = RealScalar(pow(double(ibeta), 1-it));
    relerr  = sqrt(eps);                                            // tolerance for neglecting asml
    initialized = true;
  }
  Index n = vec.size();
  RealScalar ab2 = b2 / RealScalar(n);
  RealScalar asml = RealScalar(0);
  RealScalar amed = RealScalar(0);
  RealScalar abig = RealScalar(0);
  for(typename Derived::InnerIterator it(vec, 0); it; ++it)
  {
    RealScalar ax = abs(it.value());
    if(ax > ab2)     abig += numext::abs2(ax*s2m);
    else if(ax < b1) asml += numext::abs2(ax*s1m);
    else             amed += numext::abs2(ax);
  }
  if(amed!=amed)
    return amed;  // we got a NaN
  if(abig > RealScalar(0))
  {
    abig = sqrt(abig);
    if(abig > rbig) // overflow, or *this contains INF values
      return abig;  // return INF
    if(amed > RealScalar(0))
    {
      abig = abig/s2m;
      amed = sqrt(amed);
    }
    else
      return abig/s2m;
  }
  else if(asml > RealScalar(0))
  {
    if (amed > RealScalar(0))
    {
      abig = sqrt(amed);
      amed = sqrt(asml) / s1m;
    }
    else
      return sqrt(asml)/s1m;
  }
  else
    return sqrt(amed);
  asml = numext::mini(abig, amed);
  abig = numext::maxi(abig, amed);
  if(asml <= abig*relerr)
    return abig;
  else
    return abig * sqrt(RealScalar(1) + numext::abs2(asml/abig));
}

References Eigen::EigenBase< Derived >::derived(), initialized, Eigen::numext::maxi(), Eigen::numext::mini(), and sqrt().

Referenced by Eigen::MatrixBase< Derived >::blueNorm(), and Eigen::SparseMatrixBase< Derived >::blueNorm().

Here is the call graph for this function:

Here is the caller graph for this function:

bruteforce_det3_helper()

template<typename Derived >

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

inline

{
  return matrix.coeff(0,a)
         * (matrix.coeff(1,b) * matrix.coeff(2,c) - matrix.coeff(1,c) * matrix.coeff(2,b));
}

Referenced by Eigen::internal::determinant_impl< Derived, 3 >::run().

Here is the caller graph for this function:

bruteforce_det4_helper()

template<typename Derived >

const Derived::Scalar Eigen::internal::bruteforce_det4_helper	(	const MatrixBase< Derived > &	matrix,
		int	j,
		int	k,
		int	m,
		int	n
	)

{
  return (matrix.coeff(j,0) * matrix.coeff(k,1) - matrix.coeff(k,0) * matrix.coeff(j,1))
       * (matrix.coeff(m,2) * matrix.coeff(n,3) - matrix.coeff(n,2) * matrix.coeff(m,3));
}

Referenced by Eigen::internal::determinant_impl< Derived, 4 >::run().

Here is the caller graph for this function:

c_to_fortran_numbering()

template<typename MatrixType >

void Eigen::internal::c_to_fortran_numbering

(

MatrixType &

mat

)

  {
    if ( !(mat.outerIndexPtr()[0]) ) 
    { 
      int i;
      for(i = 0; i <= mat.rows(); ++i)
        ++mat.outerIndexPtr()[i];
      for(i = 0; i < mat.nonZeros(); ++i)
        ++mat.innerIndexPtr()[i];
    }
  }

Referenced by Eigen::PastixLU< _MatrixType, IsStrSym >::grabMatrix(), Eigen::PastixLLT< _MatrixType, _UpLo >::grabMatrix(), and Eigen::PastixLDLT< _MatrixType, _UpLo >::grabMatrix().

Here is the caller graph for this function:

call_assignment() [1/5]

template<typename Dst , typename Src >

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

{
  call_assignment(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
}

References call_assignment().

Here is the call graph for this function:

call_assignment() [2/5]

template<typename Dst , typename Src >

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

{
  call_assignment(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
}

References call_assignment().

Referenced by Eigen::PlainObjectBase< Derived >::_set(), call_assignment(), call_assignment(), Eigen::DenseBase< Derived >::operator*=(), Eigen::ArrayBase< Derived >::operator+=(), Eigen::ArrayBase< Derived >::operator-=(), Eigen::DenseBase< Derived >::operator/=(), Eigen::ArrayBase< Derived >::operator=(), Eigen::DenseBase< Derived >::operator=(), Eigen::DenseBase< Derived >::operator=(), Eigen::MatrixBase< Derived >::operator=(), Eigen::MatrixBase< Derived >::operator=(), and Eigen::MatrixBase< Derived >::operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

call_assignment() [3/5]

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
	)

{
  typename plain_matrix_type<Src>::type tmp(src);
  call_assignment_no_alias(dst, tmp, func);
}

References call_assignment_no_alias().

Here is the call graph for this function:

call_assignment() [4/5]

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_no_alias(dst, src, func);
}

References call_assignment_no_alias().

Here is the call graph for this function:

call_assignment() [5/5]

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(dst.expression(), src, func);
}

References call_assignment_no_alias(), and Eigen::NoAlias< ExpressionType, StorageBase >::expression().

Here is the call graph for this function:

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(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
}

References call_assignment_no_alias().

Here is the call graph for this function:

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
	)

{
  enum {
    NeedToTranspose = (    (int(Dst::RowsAtCompileTime) == 1 && int(Src::ColsAtCompileTime) == 1)
                        || (int(Dst::ColsAtCompileTime) == 1 && int(Src::RowsAtCompileTime) == 1)
                      ) && int(Dst::SizeAtCompileTime) != 1
  };
 
  typedef typename internal::conditional<NeedToTranspose, Transpose<Dst>, Dst>::type ActualDstTypeCleaned;
  typedef typename internal::conditional<NeedToTranspose, Transpose<Dst>, Dst&>::type ActualDstType;
  ActualDstType actualDst(dst);
  
  // TODO check whether this is the right place to perform these checks:
  EIGEN_STATIC_ASSERT_LVALUE(Dst)
  EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(ActualDstTypeCleaned,Src)
  EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename ActualDstTypeCleaned::Scalar,typename Src::Scalar);
  
  Assignment<ActualDstTypeCleaned,Src,Func>::run(actualDst, src, func);
}

References EIGEN_CHECK_BINARY_COMPATIBILIY, EIGEN_STATIC_ASSERT_LVALUE, and EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE.

Referenced by Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::SparseMatrix(), Eigen::internal::unary_evaluator< Inverse< ArgType > >::unary_evaluator(), Eigen::PlainObjectBase< Derived >::_set_noalias(), Eigen::internal::generic_product_impl< Lhs, Rhs, DenseShape, DenseShape, CoeffBasedProductMode >::addTo(), call_assignment(), call_assignment(), call_assignment(), call_assignment_no_alias(), Eigen::Ref< const TPlainObjectType, Options, StrideType >::construct(), Eigen::internal::generic_product_impl< Lhs, Rhs, DenseShape, DenseShape, CoeffBasedProductMode >::evalTo(), Eigen::DenseBase< Derived >::lazyAssign(), Eigen::SparseMatrixBase< Derived >::operator=(), Eigen::SparseMatrixBase< Derived >::operator=(), Eigen::internal::Assignment< DstXprType, CwiseBinaryOp< internal::scalar_product_op< ScalarBis, Scalar >, const CwiseNullaryOp< internal::scalar_constant_op< ScalarBis >, Plain >, const Product< Lhs, Rhs, DefaultProduct > >, AssignFunc, Dense2Dense >::run(), Eigen::internal::assignment_from_xpr_op_product< DstXprType, OtherXpr, ProductType, Func1, Func2 >::run(), and Eigen::internal::generic_product_impl< Lhs, Rhs, DenseShape, DenseShape, CoeffBasedProductMode >::subTo().

Here is the caller graph for this function:

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(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
}

References call_assignment_no_alias_no_transpose().

Here is the call graph for this function:

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
	)

{
  // TODO check whether this is the right place to perform these checks:
  EIGEN_STATIC_ASSERT_LVALUE(Dst)
  EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Dst,Src)
  EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename Dst::Scalar,typename Src::Scalar);
 
  Assignment<Dst,Src,Func>::run(dst, src, func);
}

References EIGEN_CHECK_BINARY_COMPATIBILIY, EIGEN_STATIC_ASSERT_LVALUE, and EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE.

Referenced by call_assignment_no_alias_no_transpose(), Eigen::SparseSelfAdjointView< MatrixType, _Mode >::operator=(), and Eigen::internal::Assignment< DstXprType, SrcXprType, Functor, SparseSelfAdjoint2Sparse >::run().

Here is the caller graph for this function:

call_dense_assignment_loop() [1/2]

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(dst, src, internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>());
}

References call_dense_assignment_loop().

Here is the call graph for this function:

call_dense_assignment_loop() [2/2]

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
	)

{
  typedef evaluator<DstXprType> DstEvaluatorType;
  typedef evaluator<SrcXprType> SrcEvaluatorType;
 
  SrcEvaluatorType srcEvaluator(src);
 
  // NOTE To properly handle A = (A*A.transpose())/s with A rectangular,
  // we need to resize the destination after the source evaluator has been created.
  resize_if_allowed(dst, src, func);
 
  DstEvaluatorType dstEvaluator(dst);
    
  typedef generic_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorType,Functor> Kernel;
  Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
 
  dense_assignment_loop<Kernel>::run(kernel);
}

References resize_if_allowed().

Referenced by call_dense_assignment_loop(), and Eigen::internal::Assignment< DstXprType, SrcXprType, Functor, Dense2Dense, Weak >::run().

Here is the call graph for this function:

Here is the caller graph for this function:

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<Mode,SetOpposite>(dst, src, internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>());
}

References call_triangular_assignment_loop().

Here is the call graph for this function:

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
	)

{
  typedef evaluator<DstXprType> DstEvaluatorType;
  typedef evaluator<SrcXprType> SrcEvaluatorType;
 
  SrcEvaluatorType srcEvaluator(src);
 
  Index dstRows = src.rows();
  Index dstCols = src.cols();
  if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
    dst.resize(dstRows, dstCols);
  DstEvaluatorType dstEvaluator(dst);
    
  typedef triangular_dense_assignment_kernel< Mode&(Lower|Upper),Mode&(UnitDiag|ZeroDiag|SelfAdjoint),SetOpposite,
                                              DstEvaluatorType,SrcEvaluatorType,Functor> Kernel;
  Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
  
  enum {
      unroll = DstXprType::SizeAtCompileTime != Dynamic
            && SrcEvaluatorType::CoeffReadCost < HugeCost
            && DstXprType::SizeAtCompileTime * (DstEvaluatorType::CoeffReadCost+SrcEvaluatorType::CoeffReadCost) / 2 <= EIGEN_UNROLLING_LIMIT
    };
  
  triangular_assignment_loop<Kernel, Mode, unroll ? int(DstXprType::SizeAtCompileTime) : Dynamic, SetOpposite>::run(kernel);
}

References call_triangular_assignment_loop(), Eigen::Dynamic, EIGEN_UNROLLING_LIMIT, Eigen::HugeCost, Eigen::Lower, Eigen::SelfAdjoint, Eigen::UnitDiag, Eigen::Upper, and Eigen::ZeroDiag.

Referenced by call_triangular_assignment_loop(), call_triangular_assignment_loop(), and Eigen::TriangularBase< Derived >::evalToLazy().

Here is the call graph for this function:

Here is the caller graph for this function:

cast()

template<typename OldType , typename NewType >

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

inline

{
  return cast_impl<OldType, NewType>::run(x);
}

References Eigen::internal::cast_impl< OldType, NewType >::run().

Here is the call graph for this function:

check_DenseIndex_is_signed()

static void Eigen::internal::check_DenseIndex_is_signed ( )

inlinestatic

                                                {
  EIGEN_STATIC_ASSERT(NumTraits<DenseIndex>::IsSigned,THE_INDEX_TYPE_MUST_BE_A_SIGNED_TYPE); 
}

References EIGEN_STATIC_ASSERT.

check_for_aliasing()

template<typename Dst , typename Src >

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

{
  internal::checkTransposeAliasing_impl<Dst, Src>::run(dst, src);
}

References Eigen::internal::checkTransposeAliasing_impl< Derived, OtherDerived, MightHaveTransposeAliasing >::run().

Here is the call graph for this function:

check_size_for_overflow()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void Eigen::internal::check_size_for_overflow

(

std::size_t

size

)

{
  if(size > std::size_t(-1) / sizeof(T))
    throw_std_bad_alloc();
}

References throw_std_bad_alloc().

Here is the call graph for this function:

check_static_allocation_size()

template<typename T , int Size>

EIGEN_DEVICE_FUNC void Eigen::internal::check_static_allocation_size

(

)

{
  // if EIGEN_STACK_ALLOCATION_LIMIT is defined to 0, then no limit
  #if EIGEN_STACK_ALLOCATION_LIMIT
  EIGEN_STATIC_ASSERT(Size * sizeof(T) <= EIGEN_STACK_ALLOCATION_LIMIT, OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG);
  #endif
}

References EIGEN_STACK_ALLOCATION_LIMIT, and EIGEN_STATIC_ASSERT.

check_that_malloc_is_allowed()

EIGEN_DEVICE_FUNC void Eigen::internal::check_that_malloc_is_allowed ( )

inline

{}

Referenced by aligned_malloc(), and conditional_aligned_malloc< false >().

Here is the caller graph for this function:

cofactor_3x3()

template<typename MatrixType , int i, int j>

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

inline

{
  enum {
    i1 = (i+1) % 3,
    i2 = (i+2) % 3,
    j1 = (j+1) % 3,
    j2 = (j+2) % 3
  };
  return m.coeff(i1, j1) * m.coeff(i2, j2)
       - m.coeff(i1, j2) * m.coeff(i2, j1);
}

cofactor_4x4()

template<typename MatrixType , int i, int j>

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

inline

{
  enum {
    i1 = (i+1) % 4,
    i2 = (i+2) % 4,
    i3 = (i+3) % 4,
    j1 = (j+1) % 4,
    j2 = (j+2) % 4,
    j3 = (j+3) % 4
  };
  return general_det3_helper(matrix, i1, i2, i3, j1, j2, j3)
       + general_det3_helper(matrix, i2, i3, i1, j1, j2, j3)
       + general_det3_helper(matrix, i3, i1, i2, j1, j2, j3);
}

References general_det3_helper().

Here is the call graph for this function:

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

{
  typedef typename MatrixType::StorageIndex StorageIndex;
  StorageIndex nc = convert_index<StorageIndex>(mat.cols()); // Number of columns
  StorageIndex m = convert_index<StorageIndex>(mat.rows());
  StorageIndex diagSize = (std::min)(nc,m);
  IndexVector root(nc); // root of subtree of etree 
  root.setZero();
  IndexVector pp(nc); // disjoint sets 
  pp.setZero(); // Initialize disjoint sets 
  parent.resize(mat.cols());
  //Compute first nonzero column in each row 
  firstRowElt.resize(m);
  firstRowElt.setConstant(nc);
  firstRowElt.segment(0, diagSize).setLinSpaced(diagSize, 0, diagSize-1);
  bool found_diag;
  for (StorageIndex col = 0; col < nc; col++)
  {
    StorageIndex pcol = col;
    if(perm) pcol  = perm[col];
    for (typename MatrixType::InnerIterator it(mat, pcol); it; ++it)
    { 
      Index row = it.row();
      firstRowElt(row) = (std::min)(firstRowElt(row), col);
    }
  }
  /* Compute etree by Liu's algorithm for symmetric matrices,
          except use (firstRowElt[r],c) in place of an edge (r,c) of A.
    Thus each row clique in A'*A is replaced by a star
    centered at its first vertex, which has the same fill. */
  StorageIndex rset, cset, rroot;
  for (StorageIndex col = 0; col < nc; col++) 
  {
    found_diag = col>=m;
    pp(col) = col; 
    cset = col; 
    root(cset) = col; 
    parent(col) = nc; 
    /* The diagonal element is treated here even if it does not exist in the matrix
     * hence the loop is executed once more */ 
    StorageIndex pcol = col;
    if(perm) pcol  = perm[col];
    for (typename MatrixType::InnerIterator it(mat, pcol); it||!found_diag; ++it)
    { //  A sequence of interleaved find and union is performed 
      Index i = col;
      if(it) i = it.index();
      if (i == col) found_diag = true;
      
      StorageIndex row = firstRowElt(i);
      if (row >= col) continue; 
      rset = internal::etree_find(row, pp); // Find the name of the set containing row
      rroot = root(rset);
      if (rroot != col) 
      {
        parent(rroot) = col; 
        pp(cset) = rset; 
        cset = rset; 
        root(cset) = col; 
      }
    }
  }
  return 0;  
}

References col(), etree_find(), and row().

Referenced by Eigen::SparseQR< _MatrixType, _OrderingType >::analyzePattern(), Eigen::SparseLU< _MatrixType, _OrderingType >::analyzePattern(), and Eigen::SparseQR< _MatrixType, _OrderingType >::factorize().

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
  result.coeffRef(0,0) =  matrix.coeff(1,1) * invdet;
  result.coeffRef(1,0) = -matrix.coeff(1,0) * invdet;
  result.coeffRef(0,1) = -matrix.coeff(0,1) * invdet;
  result.coeffRef(1,1) =  matrix.coeff(0,0) * invdet;
}

Referenced by Eigen::internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 2 >::run(), and Eigen::internal::compute_inverse< MatrixType, ResultType, 2 >::run().

Here is the caller graph for this function:

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

{
  result.row(0) = cofactors_col0 * invdet;
  result.coeffRef(1,0) =  cofactor_3x3<MatrixType,0,1>(matrix) * invdet;
  result.coeffRef(1,1) =  cofactor_3x3<MatrixType,1,1>(matrix) * invdet;
  result.coeffRef(1,2) =  cofactor_3x3<MatrixType,2,1>(matrix) * invdet;
  result.coeffRef(2,0) =  cofactor_3x3<MatrixType,0,2>(matrix) * invdet;
  result.coeffRef(2,1) =  cofactor_3x3<MatrixType,1,2>(matrix) * invdet;
  result.coeffRef(2,2) =  cofactor_3x3<MatrixType,2,2>(matrix) * invdet;
}

References Eigen::Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >::coeffRef().

Referenced by Eigen::internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 3 >::run(), and Eigen::internal::compute_inverse< MatrixType, ResultType, 3 >::run().

Here is the call graph for this function:

Here is the caller graph for this function:

computeFromTridiagonal_impl()

template<typename MatrixType , typename DiagType , typename SubDiagType >

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

{
  using std::abs;
 
  ComputationInfo info;
  typedef typename MatrixType::Scalar Scalar;
 
  Index n = diag.size();
  Index end = n-1;
  Index start = 0;
  Index iter = 0; // total number of iterations
  
  typedef typename DiagType::RealScalar RealScalar;
  const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
  const RealScalar precision = RealScalar(2)*NumTraits<RealScalar>::epsilon();
  
  while (end>0)
  {
    for (Index i = start; i<end; ++i)
      if (internal::isMuchSmallerThan(abs(subdiag[i]),(abs(diag[i])+abs(diag[i+1])),precision) || abs(subdiag[i]) <= considerAsZero)
        subdiag[i] = 0;
 
    // find the largest unreduced block
    while (end>0 && subdiag[end-1]==RealScalar(0))
    {
      end--;
    }
    if (end<=0)
      break;
 
    // if we spent too many iterations, we give up
    iter++;
    if(iter > maxIterations * n) break;
 
    start = end - 1;
    while (start>0 && subdiag[start-1]!=0)
      start--;
 
    internal::tridiagonal_qr_step<MatrixType::Flags&RowMajorBit ? RowMajor : ColMajor>(diag.data(), subdiag.data(), start, end, computeEigenvectors ? eivec.data() : (Scalar*)0, n);
  }
  if (iter <= maxIterations * n)
    info = Success;
  else
    info = NoConvergence;
 
  // Sort eigenvalues and corresponding vectors.
  // TODO make the sort optional ?
  // TODO use a better sort algorithm !!
  if (info == Success)
  {
    for (Index i = 0; i < n-1; ++i)
    {
      Index k;
      diag.segment(i,n-i).minCoeff(&k);
      if (k > 0)
      {
        std::swap(diag[i], diag[k+i]);
        if(computeEigenvectors)
          eivec.col(i).swap(eivec.col(k+i));
      }
    }
  }
  return info;
}

References Eigen::end(), isMuchSmallerThan(), Eigen::NoConvergence, and Eigen::Success.

Referenced by Eigen::SelfAdjointEigenSolver< _MatrixType >::compute(), and Eigen::SelfAdjointEigenSolver< _MatrixType >::computeFromTridiagonal().

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
  if (!useSpecificBlockingSizes(k, m, n)) {
    evaluateProductBlockingSizesHeuristic<LhsScalar, RhsScalar, KcFactor, Index>(k, m, n, num_threads);
  }
}

References useSpecificBlockingSizes().

Here is the call graph for this function:

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

{
  computeProductBlockingSizes<LhsScalar,RhsScalar,1,Index>(k, m, n, num_threads);
}

conditional_aligned_delete()

template<typename T , bool Align>

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

inline

{
  destruct_elements_of_array<T>(ptr, size);
  conditional_aligned_free<Align>(ptr);
}

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

{
  if(NumTraits<T>::RequireInitialization)
    destruct_elements_of_array<T>(ptr, size);
  conditional_aligned_free<Align>(ptr);
}

conditional_aligned_free()

template<bool Align>

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

inline

{
  aligned_free(ptr);
}

References aligned_free().

Here is the call graph for this function:

conditional_aligned_free< false >()

template<>

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

inline

{
  std::free(ptr);
}

conditional_aligned_malloc()

template<bool Align>

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

inline

{
  return aligned_malloc(size);
}

References aligned_malloc().

Here is the call graph for this function:

conditional_aligned_malloc< false >()

template<>

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

inline

{
  check_that_malloc_is_allowed();
 
  void *result = std::malloc(size);
  if(!result && size)
    throw_std_bad_alloc();
  return result;
}

References check_that_malloc_is_allowed(), and throw_std_bad_alloc().

Here is the call graph for this function:

conditional_aligned_new()

template<typename T , bool Align>

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

inline

{
  check_size_for_overflow<T>(size);
  T *result = reinterpret_cast<T*>(conditional_aligned_malloc<Align>(sizeof(T)*size));
  EIGEN_TRY
  {
    return construct_elements_of_array(result, size);
  }
  EIGEN_CATCH(...)
  {
    conditional_aligned_free<Align>(result);
    EIGEN_THROW;
  }
  return result;
}

References construct_elements_of_array(), EIGEN_CATCH, EIGEN_THROW, and EIGEN_TRY.

Here is the call graph for this function:

conditional_aligned_new_auto()

template<typename T , bool Align>

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

inline

{
  if(size==0)
    return 0; // short-cut. Also fixes Bug 884
  check_size_for_overflow<T>(size);
  T *result = reinterpret_cast<T*>(conditional_aligned_malloc<Align>(sizeof(T)*size));
  if(NumTraits<T>::RequireInitialization)
  {
    EIGEN_TRY
    {
      construct_elements_of_array(result, size);
    }
    EIGEN_CATCH(...)
    {
      conditional_aligned_free<Align>(result);
      EIGEN_THROW;
    }
  }
  return result;
}

References construct_elements_of_array(), EIGEN_CATCH, EIGEN_THROW, and EIGEN_TRY.

Here is the call graph for this function:

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

{
  return aligned_realloc(ptr, new_size, old_size);
}

References aligned_realloc().

Here is the call graph for this function:

conditional_aligned_realloc< false >()

template<>

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

inline

{
  return std::realloc(ptr, new_size);
}

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

{
  check_size_for_overflow<T>(new_size);
  check_size_for_overflow<T>(old_size);
  if(new_size < old_size)
    destruct_elements_of_array(pts+new_size, old_size-new_size);
  T *result = reinterpret_cast<T*>(conditional_aligned_realloc<Align>(reinterpret_cast<void*>(pts), sizeof(T)*new_size, sizeof(T)*old_size));
  if(new_size > old_size)
  {
    EIGEN_TRY
    {
      construct_elements_of_array(result+old_size, new_size-old_size);
    }
    EIGEN_CATCH(...)
    {
      conditional_aligned_free<Align>(result);
      EIGEN_THROW;
    }
  }
  return result;
}

References construct_elements_of_array(), destruct_elements_of_array(), EIGEN_CATCH, EIGEN_THROW, and EIGEN_TRY.

Here is the call graph for this function:

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

{
  check_size_for_overflow<T>(new_size);
  check_size_for_overflow<T>(old_size);
  if(NumTraits<T>::RequireInitialization && (new_size < old_size))
    destruct_elements_of_array(pts+new_size, old_size-new_size);
  T *result = reinterpret_cast<T*>(conditional_aligned_realloc<Align>(reinterpret_cast<void*>(pts), sizeof(T)*new_size, sizeof(T)*old_size));
  if(NumTraits<T>::RequireInitialization && (new_size > old_size))
  {
    EIGEN_TRY
    {
      construct_elements_of_array(result+old_size, new_size-old_size);
    }
    EIGEN_CATCH(...)
    {
      conditional_aligned_free<Align>(result);
      EIGEN_THROW;
    }
  }
  return result;
}

References construct_elements_of_array(), destruct_elements_of_array(), EIGEN_CATCH, EIGEN_THROW, and EIGEN_TRY.

Here is the call graph for this function:

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
	)

{
  using std::sqrt;
  using std::abs;
  typedef typename Dest::RealScalar RealScalar;
  typedef typename Dest::Scalar Scalar;
  typedef Matrix<Scalar,Dynamic,1> VectorType;
  
  RealScalar tol = tol_error;
  Index maxIters = iters;
  
  Index n = mat.cols();
 
  VectorType residual = rhs - mat * x; //initial residual
 
  RealScalar rhsNorm2 = rhs.squaredNorm();
  if(rhsNorm2 == 0) 
  {
    x.setZero();
    iters = 0;
    tol_error = 0;
    return;
  }
  const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
  RealScalar threshold = numext::maxi(tol*tol*rhsNorm2,considerAsZero);
  RealScalar residualNorm2 = residual.squaredNorm();
  if (residualNorm2 < threshold)
  {
    iters = 0;
    tol_error = sqrt(residualNorm2 / rhsNorm2);
    return;
  }
 
  VectorType p(n);
  p = precond.solve(residual);      // initial search direction
 
  VectorType z(n), tmp(n);
  RealScalar absNew = numext::real(residual.dot(p));  // the square of the absolute value of r scaled by invM
  Index i = 0;
  while(i < maxIters)
  {
    tmp.noalias() = mat * p;                    // the bottleneck of the algorithm
 
    Scalar alpha = absNew / p.dot(tmp);         // the amount we travel on dir
    x += alpha * p;                             // update solution
    residual -= alpha * tmp;                    // update residual
    
    residualNorm2 = residual.squaredNorm();
    if(residualNorm2 < threshold)
      break;
    
    z = precond.solve(residual);                // approximately solve for "A z = residual"
 
    RealScalar absOld = absNew;
    absNew = numext::real(residual.dot(z));     // update the absolute value of r
    RealScalar beta = absNew / absOld;          // calculate the Gram-Schmidt value used to create the new search direction
    p = z + beta * p;                           // update search direction
    i++;
  }
  tol_error = sqrt(residualNorm2 / rhsNorm2);
  iters = i;
}

References Eigen::PlainObjectBase< Derived >::cols(), Eigen::numext::maxi(), and sqrt().

Referenced by Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::_solve_with_guess_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

conservative_sparse_sparse_product_impl()

template<typename Lhs , typename Rhs , typename ResultType >

static void Eigen::internal::conservative_sparse_sparse_product_impl ( const Lhs &  lhs, const Rhs &  rhs, ResultType &  res, bool  sortedInsertion = false  )

static

{
  typedef typename remove_all<Lhs>::type::Scalar LhsScalar;
  typedef typename remove_all<Rhs>::type::Scalar RhsScalar;
  typedef typename remove_all<ResultType>::type::Scalar ResScalar;
 
  // make sure to call innerSize/outerSize since we fake the storage order.
  Index rows = lhs.innerSize();
  Index cols = rhs.outerSize();
  eigen_assert(lhs.outerSize() == rhs.innerSize());
  
  ei_declare_aligned_stack_constructed_variable(bool,   mask,     rows, 0);
  ei_declare_aligned_stack_constructed_variable(ResScalar, values,   rows, 0);
  ei_declare_aligned_stack_constructed_variable(Index,  indices,  rows, 0);
  
  std::memset(mask,0,sizeof(bool)*rows);
 
  evaluator<Lhs> lhsEval(lhs);
  evaluator<Rhs> rhsEval(rhs);
  
  // estimate the number of non zero entries
  // given a rhs column containing Y non zeros, we assume that the respective Y columns
  // of the lhs differs in average of one non zeros, thus the number of non zeros for
  // the product of a rhs column with the lhs is X+Y where X is the average number of non zero
  // per column of the lhs.
  // Therefore, we have nnz(lhs*rhs) = nnz(lhs) + nnz(rhs)
  Index estimated_nnz_prod = lhsEval.nonZerosEstimate() + rhsEval.nonZerosEstimate();
 
  res.setZero();
  res.reserve(Index(estimated_nnz_prod));
  // we compute each column of the result, one after the other
  for (Index j=0; j<cols; ++j)
  {
 
    res.startVec(j);
    Index nnz = 0;
    for (typename evaluator<Rhs>::InnerIterator rhsIt(rhsEval, j); rhsIt; ++rhsIt)
    {
      RhsScalar y = rhsIt.value();
      Index k = rhsIt.index();
      for (typename evaluator<Lhs>::InnerIterator lhsIt(lhsEval, k); lhsIt; ++lhsIt)
      {
        Index i = lhsIt.index();
        LhsScalar x = lhsIt.value();
        if(!mask[i])
        {
          mask[i] = true;
          values[i] = x * y;
          indices[nnz] = i;
          ++nnz;
        }
        else
          values[i] += x * y;
      }
    }
    if(!sortedInsertion)
    {
      // unordered insertion
      for(Index k=0; k<nnz; ++k)
      {
        Index i = indices[k];
        res.insertBackByOuterInnerUnordered(j,i) = values[i];
        mask[i] = false;
      }
    }
    else
    {
      // alternative ordered insertion code:
      const Index t200 = rows/11; // 11 == (log2(200)*1.39)
      const Index t = (rows*100)/139;
 
      // FIXME reserve nnz non zeros
      // FIXME implement faster sorting algorithms for very small nnz
      // if the result is sparse enough => use a quick sort
      // otherwise => loop through the entire vector
      // In order to avoid to perform an expensive log2 when the
      // result is clearly very sparse we use a linear bound up to 200.
      if((nnz<200 && nnz<t200) || nnz * numext::log2(int(nnz)) < t)
      {
        if(nnz>1) std::sort(indices,indices+nnz);
        for(Index k=0; k<nnz; ++k)
        {
          Index i = indices[k];
          res.insertBackByOuterInner(j,i) = values[i];
          mask[i] = false;
        }
      }
      else
      {
        // dense path
        for(Index i=0; i<rows; ++i)
        {
          if(mask[i])
          {
            mask[i] = false;
            res.insertBackByOuterInner(j,i) = values[i];
          }
        }
      }
    }
  }
  res.finalize();
}

References ei_declare_aligned_stack_constructed_variable, eigen_assert, Eigen::numext::log2(), and y.

Here is the call graph for this function:

const_cast_ptr()

template<typename T >

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

inline

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

construct_elements_of_array()

template<typename T >

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

inline

{
  std::size_t i;
  EIGEN_TRY
  {
      for (i = 0; i < size; ++i) ::new (ptr + i) T;
      return ptr;
  }
  EIGEN_CATCH(...)
  {
    destruct_elements_of_array(ptr, i);
    EIGEN_THROW;
  }
  return NULL;
}

References destruct_elements_of_array(), EIGEN_CATCH, EIGEN_THROW, and EIGEN_TRY.

Referenced by Eigen::internal::aligned_stack_memory_handler< T >::aligned_stack_memory_handler(), aligned_new(), conditional_aligned_new(), conditional_aligned_new_auto(), conditional_aligned_realloc_new(), and conditional_aligned_realloc_new_auto().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_index()

template<typename IndexDest , typename IndexSrc >

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

inline

                                                    {
  // for sizeof(IndexDest)>=sizeof(IndexSrc) compilers should be able to optimize this away:
  eigen_internal_assert(idx <= NumTraits<IndexDest>::highest() && "Index value to big for target type");
  return IndexDest(idx);
}

References eigen_internal_assert.

Referenced by Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::coeffRef(), and Eigen::IncompleteLUT< _Scalar, _StorageIndex >::factorize().

Here is the caller graph for this function:

cs_tdfs()

template<typename StorageIndex >

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

{
  StorageIndex i, p, top = 0;
  if(!head || !next || !post || !stack) return (-1);    /* check inputs */
  stack[0] = j;                 /* place j on the stack */
  while (top >= 0)                /* while (stack is not empty) */
  {
    p = stack[top];           /* p = top of stack */
    i = head[p];              /* i = youngest child of p */
    if(i == -1)
    {
      top--;                 /* p has no unordered children left */
      post[k++] = p;        /* node p is the kth postordered node */
    }
    else
    {
      head[p] = next[i];   /* remove i from children of p */
      stack[++top] = i;     /* start dfs on child node i */
    }
  }
  return k;
}

References head().

Here is the call graph for this function:

cs_wclear()

template<typename StorageIndex >

static StorageIndex Eigen::internal::cs_wclear ( StorageIndex  mark, StorageIndex  lemax, StorageIndex *  w, StorageIndex  n  )

static

{
  StorageIndex k;
  if(mark < 2 || (mark + lemax < 0))
  {
    for(k = 0; k < n; k++)
      if(w[k] != 0)
        w[k] = 1;
    mark = 2;
  }
  return (mark);     /* at this point, w[0..n-1] < mark holds */
}

destruct_elements_of_array()

template<typename T >

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

inline

{
  // always destruct an array starting from the end.
  if(ptr)
    while(size) ptr[--size].~T();
}

Referenced by conditional_aligned_realloc_new(), conditional_aligned_realloc_new_auto(), and construct_elements_of_array().

Here is the caller graph for this function:

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_MATHFUNC_RETVAL() [1/2]

template<typename Scalar >

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

inline

{
  return EIGEN_MATHFUNC_IMPL(random, Scalar)::run();
}

References EIGEN_MATHFUNC_IMPL, and random.

EIGEN_MATHFUNC_RETVAL() [2/2]

template<typename Scalar >

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

inline

EIGEN_MEMBER_FUNCTOR() [1/13]

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

EIGEN_MEMBER_FUNCTOR() [2/13]

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

EIGEN_MEMBER_FUNCTOR() [3/13]

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

EIGEN_MEMBER_FUNCTOR() [4/13]

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

EIGEN_MEMBER_FUNCTOR() [5/13]

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

EIGEN_MEMBER_FUNCTOR() [6/13]

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

EIGEN_MEMBER_FUNCTOR() [7/13]

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

EIGEN_MEMBER_FUNCTOR() [8/13]

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

EIGEN_MEMBER_FUNCTOR() [9/13]

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

EIGEN_MEMBER_FUNCTOR() [10/13]

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

EIGEN_MEMBER_FUNCTOR() [11/13]

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

EIGEN_MEMBER_FUNCTOR() [12/13]

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

EIGEN_MEMBER_FUNCTOR() [13/13]

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

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

  {
    if (n == 0) { ptr = NULL; idx = NULL; vals = NULL; }
    if (nbrhs == 0) {x = NULL; nbrhs=1;}
    d_pastix(pastix_data, pastix_comm, n, ptr, idx, vals, perm, invp, x, nbrhs, iparm, dparm); 
  }

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

  {
    if (n == 0) { ptr = NULL; idx = NULL; vals = NULL; }
    if (nbrhs == 0) {x = NULL; nbrhs=1;}
    s_pastix(pastix_data, pastix_comm, n, ptr, idx, vals, perm, invp, x, nbrhs, iparm, dparm); 
  }

Referenced by Eigen::PastixBase< Derived >::_solve_impl(), Eigen::PastixBase< Derived >::analyzePattern(), Eigen::PastixBase< Derived >::clean(), Eigen::PastixBase< Derived >::factorize(), and Eigen::PastixBase< Derived >::init().

Here is the caller graph for this function:

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

  {
    if (n == 0) { ptr = NULL; idx = NULL; vals = NULL; }
    if (nbrhs == 0) {x = NULL; nbrhs=1;}
    z_pastix(pastix_data, pastix_comm, n, ptr, idx, reinterpret_cast<PASTIX_DCOMPLEX*>(vals), perm, invp, reinterpret_cast<PASTIX_DCOMPLEX*>(x), nbrhs, iparm, dparm); 
  }

References PASTIX_DCOMPLEX.

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

  {
    if (n == 0) { ptr = NULL; idx = NULL; vals = NULL; }
    if (nbrhs == 0) {x = NULL; nbrhs=1;}
    c_pastix(pastix_data, pastix_comm, n, ptr, idx, reinterpret_cast<PASTIX_COMPLEX*>(vals), perm, invp, reinterpret_cast<PASTIX_COMPLEX*>(x), nbrhs, iparm, dparm); 
  }

References PASTIX_COMPLEX.

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

{
  Index p = pp(i); // Parent 
  Index gp = pp(p); // Grand parent 
  while (gp != p) 
  {
    pp(i) = gp; // Parent pointer on find path is changed to former grand parent
    i = gp; 
    p = pp(i);
    gp = pp(p);
  }
  return p; 
}

Referenced by coletree().

Here is the caller graph for this function:

evaluateProductBlockingSizesHeuristic()

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

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

{
  typedef gebp_traits<LhsScalar,RhsScalar> Traits;
 
  // Explanations:
  // Let's recall that the product algorithms form mc x kc vertical panels A' on the lhs and
  // kc x nc blocks B' on the rhs. B' has to fit into L2/L3 cache. Moreover, A' is processed
  // per mr x kc horizontal small panels where mr is the blocking size along the m dimension
  // at the register level. This small horizontal panel has to stay within L1 cache.
  std::ptrdiff_t l1, l2, l3;
  manage_caching_sizes(GetAction, &l1, &l2, &l3);
 
  if (num_threads > 1) {
    typedef typename Traits::ResScalar ResScalar;
    enum {
      kdiv = KcFactor * (Traits::mr * sizeof(LhsScalar) + Traits::nr * sizeof(RhsScalar)),
      ksub = Traits::mr * Traits::nr * sizeof(ResScalar),
      kr = 8,
      mr = Traits::mr,
      nr = Traits::nr
    };
    // Increasing k gives us more time to prefetch the content of the "C"
    // registers. However once the latency is hidden there is no point in
    // increasing the value of k, so we'll cap it at 320 (value determined
    // experimentally).
    const Index k_cache = (numext::mini<Index>)((l1-ksub)/kdiv, 320);
    if (k_cache < k) {
      k = k_cache - (k_cache % kr);
      eigen_internal_assert(k > 0);
    }
 
    const Index n_cache = (l2-l1) / (nr * sizeof(RhsScalar) * k);
    const Index n_per_thread = numext::div_ceil(n, num_threads);
    if (n_cache <= n_per_thread) {
      // Don't exceed the capacity of the l2 cache.
      eigen_internal_assert(n_cache >= static_cast<Index>(nr));
      n = n_cache - (n_cache % nr);
      eigen_internal_assert(n > 0);
    } else {
      n = (numext::mini<Index>)(n, (n_per_thread + nr - 1) - ((n_per_thread + nr - 1) % nr));
    }
 
    if (l3 > l2) {
      // l3 is shared between all cores, so we'll give each thread its own chunk of l3.
      const Index m_cache = (l3-l2) / (sizeof(LhsScalar) * k * num_threads);
      const Index m_per_thread = numext::div_ceil(m, num_threads);
      if(m_cache < m_per_thread && m_cache >= static_cast<Index>(mr)) {
        m = m_cache - (m_cache % mr);
        eigen_internal_assert(m > 0);
      } else {
        m = (numext::mini<Index>)(m, (m_per_thread + mr - 1) - ((m_per_thread + mr - 1) % mr));
      }
    }
  }
  else {
    // In unit tests we do not want to use extra large matrices,
    // so we reduce the cache size to check the blocking strategy is not flawed
#ifdef EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS
    l1 = 9*1024;
    l2 = 32*1024;
    l3 = 512*1024;
#endif
 
    // Early return for small problems because the computation below are time consuming for small problems.
    // Perhaps it would make more sense to consider k*n*m??
    // Note that for very tiny problem, this function should be bypassed anyway
    // because we use the coefficient-based implementation for them.
    if((numext::maxi)(k,(numext::maxi)(m,n))<48)
      return;
 
    typedef typename Traits::ResScalar ResScalar;
    enum {
      k_peeling = 8,
      k_div = KcFactor * (Traits::mr * sizeof(LhsScalar) + Traits::nr * sizeof(RhsScalar)),
      k_sub = Traits::mr * Traits::nr * sizeof(ResScalar)
    };
 
    // ---- 1st level of blocking on L1, yields kc ----
 
    // Blocking on the third dimension (i.e., k) is chosen so that an horizontal panel
    // of size mr x kc of the lhs plus a vertical panel of kc x nr of the rhs both fits within L1 cache.
    // We also include a register-level block of the result (mx x nr).
    // (In an ideal world only the lhs panel would stay in L1)
    // Moreover, kc has to be a multiple of 8 to be compatible with loop peeling, leading to a maximum blocking size of:
    const Index max_kc = numext::maxi<Index>(((l1-k_sub)/k_div) & (~(k_peeling-1)),1);
    const Index old_k = k;
    if(k>max_kc)
    {
      // We are really blocking on the third dimension:
      // -> reduce blocking size to make sure the last block is as large as possible
      //    while keeping the same number of sweeps over the result.
      k = (k%max_kc)==0 ? max_kc
                        : max_kc - k_peeling * ((max_kc-1-(k%max_kc))/(k_peeling*(k/max_kc+1)));
 
      eigen_internal_assert(((old_k/k) == (old_k/max_kc)) && "the number of sweeps has to remain the same");
    }
 
    // ---- 2nd level of blocking on max(L2,L3), yields nc ----
 
    // TODO find a reliable way to get the actual amount of cache per core to use for 2nd level blocking, that is:
    //      actual_l2 = max(l2, l3/nb_core_sharing_l3)
    // The number below is quite conservative: it is better to underestimate the cache size rather than overestimating it)
    // For instance, it corresponds to 6MB of L3 shared among 4 cores.
    #ifdef EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS
    const Index actual_l2 = l3;
    #else
    const Index actual_l2 = 1572864; // == 1.5 MB
    #endif
 
    // Here, nc is chosen such that a block of kc x nc of the rhs fit within half of L2.
    // The second half is implicitly reserved to access the result and lhs coefficients.
    // When k<max_kc, then nc can arbitrarily growth. In practice, it seems to be fruitful
    // to limit this growth: we bound nc to growth by a factor x1.5.
    // However, if the entire lhs block fit within L1, then we are not going to block on the rows at all,
    // and it becomes fruitful to keep the packed rhs blocks in L1 if there is enough remaining space.
    Index max_nc;
    const Index lhs_bytes = m * k * sizeof(LhsScalar);
    const Index remaining_l1 = l1- k_sub - lhs_bytes;
    if(remaining_l1 >= Index(Traits::nr*sizeof(RhsScalar))*k)
    {
      // L1 blocking
      max_nc = remaining_l1 / (k*sizeof(RhsScalar));
    }
    else
    {
      // L2 blocking
      max_nc = (3*actual_l2)/(2*2*max_kc*sizeof(RhsScalar));
    }
    // WARNING Below, we assume that Traits::nr is a power of two.
    Index nc = numext::mini<Index>(actual_l2/(2*k*sizeof(RhsScalar)), max_nc) & (~(Traits::nr-1));
    if(n>nc)
    {
      // We are really blocking over the columns:
      // -> reduce blocking size to make sure the last block is as large as possible
      //    while keeping the same number of sweeps over the packed lhs.
      //    Here we allow one more sweep if this gives us a perfect match, thus the commented "-1"
      n = (n%nc)==0 ? nc
                    : (nc - Traits::nr * ((nc/*-1*/-(n%nc))/(Traits::nr*(n/nc+1))));
    }
    else if(old_k==k)
    {
      // So far, no blocking at all, i.e., kc==k, and nc==n.
      // In this case, let's perform a blocking over the rows such that the packed lhs data is kept in cache L1/L2
      // TODO: part of this blocking strategy is now implemented within the kernel itself, so the L1-based heuristic here should be obsolete.
      Index problem_size = k*n*sizeof(LhsScalar);
      Index actual_lm = actual_l2;
      Index max_mc = m;
      if(problem_size<=1024)
      {
        // problem is small enough to keep in L1
        // Let's choose m such that lhs's block fit in 1/3 of L1
        actual_lm = l1;
      }
      else if(l3!=0 && problem_size<=32768)
      {
        // we have both L2 and L3, and problem is small enough to be kept in L2
        // Let's choose m such that lhs's block fit in 1/3 of L2
        actual_lm = l2;
        max_mc = (numext::mini<Index>)(576,max_mc);
      }
      Index mc = (numext::mini<Index>)(actual_lm/(3*k*sizeof(LhsScalar)), max_mc);
      if (mc > Traits::mr) mc -= mc % Traits::mr;
      else if (mc==0) return;
      m = (m%mc)==0 ? mc
                    : (mc - Traits::mr * ((mc/*-1*/-(m%mc))/(Traits::mr*(m/mc+1))));
    }
  }
}

References Eigen::numext::div_ceil(), eigen_internal_assert, Eigen::GetAction, manage_caching_sizes(), and Eigen::numext::maxi().

Here is the call graph for this function:

extract_data()

template<typename T >

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

(

const T &

m

)

{
  return extract_data_selector<T>::run(m);
}

References Eigen::internal::extract_data_selector< T, HasUsableDirectAccess >::run().

Referenced by Eigen::TriangularViewImpl< MatrixType, Mode, Sparse >::_solve_impl(), Eigen::internal::checkTransposeAliasing_impl< Derived, OtherDerived, MightHaveTransposeAliasing >::run(), Eigen::internal::check_transpose_aliasing_run_time_selector< Scalar, DestIsTransposed, CwiseBinaryOp< BinOp, DerivedA, DerivedB > >::run(), Eigen::internal::check_transpose_aliasing_run_time_selector< Scalar, DestIsTransposed, OtherDerived >::run(), and Eigen::internal::Assignment< DstXprType, Inverse< XprType >, internal::assign_op< typename DstXprType::Scalar, typename XprType::Scalar >, Dense2Dense >::run().

Here is the call graph for this function:

Here is the caller graph for this function:

first_aligned() [1/2]

template<int Alignment, typename Derived >

static Index Eigen::internal::first_aligned ( const DenseBase< Derived > &  m )

inlinestatic

{
  enum { ReturnZero = (int(evaluator<Derived>::Alignment) >= Alignment) || !(Derived::Flags & DirectAccessBit) };
  return first_aligned_impl<Alignment, Derived, ReturnZero>::run(m.derived());
}

References Eigen::DirectAccessBit, and Eigen::internal::first_aligned_impl< Alignment, Derived, JustReturnZero >::run().

Referenced by first_default_aligned().

Here is the call graph for this function:

Here is the caller graph for this function:

first_aligned() [2/2]

template<int Alignment, typename Scalar , typename Index >

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

inline

{
  const Index ScalarSize = sizeof(Scalar);
  const Index AlignmentSize = Alignment / ScalarSize;
  const Index AlignmentMask = AlignmentSize-1;
 
  if(AlignmentSize<=1)
  {
    // Either the requested alignment if smaller than a scalar, or it exactly match a 1 scalar
    // so that all elements of the array have the same alignment.
    return 0;
  }
  else if( (UIntPtr(array) & (sizeof(Scalar)-1)) || (Alignment%ScalarSize)!=0)
  {
    // The array is not aligned to the size of a single scalar, or the requested alignment is not a multiple of the scalar size.
    // Consequently, no element of the array is well aligned.
    return size;
  }
  else
  {
    Index first = (AlignmentSize - (Index((UIntPtr(array)/sizeof(Scalar))) & AlignmentMask)) & AlignmentMask;
    return (first < size) ? first : size;
  }
}

first_default_aligned() [1/2]

template<typename Derived >

static Index Eigen::internal::first_default_aligned ( const DenseBase< Derived > &  m )

inlinestatic

{
  typedef typename Derived::Scalar Scalar;
  typedef typename packet_traits<Scalar>::type DefaultPacketType;
  return internal::first_aligned<int(unpacket_traits<DefaultPacketType>::alignment),Derived>(m);
}

References first_aligned().

Referenced by Eigen::internal::blas_data_mapper< Scalar, Index, StorageOrder, AlignmentType >::firstAligned(), Eigen::internal::SparseLUImpl< Scalar, StorageIndex >::panel_bmod(), Eigen::internal::redux_impl< Func, Derived, LinearVectorizedTraversal, NoUnrolling >::run(), Eigen::internal::LU_kernel_bmod< SegSizeAtCompileTime >::run(), Eigen::internal::general_matrix_vector_product< Index, LhsScalar, LhsMapper, ColMajor, ConjugateLhs, RhsScalar, RhsMapper, ConjugateRhs, Version >::run(), Eigen::internal::selfadjoint_matrix_vector_product< Scalar, Index, StorageOrder, UpLo, ConjugateLhs, ConjugateRhs, Version >::run(), Eigen::internal::apply_rotation_in_the_plane_selector< Scalar, OtherScalar, SizeAtCompileTime, MinAlignment, true >::run(), sparselu_gemm(), and Eigen::MatrixBase< Derived >::stableNorm().

Here is the call graph for this function:

Here is the caller graph for this function:

first_default_aligned() [2/2]

template<typename Scalar , typename Index >

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

inline

{
  typedef typename packet_traits<Scalar>::type DefaultPacketType;
  return first_aligned<unpacket_traits<DefaultPacketType>::alignment>(array, size);
}

first_multiple()

template<typename Index >

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

inline

{
  return ((size+base-1)/base)*base;
}

Referenced by Eigen::internal::LU_kernel_bmod< SegSizeAtCompileTime >::run().

Here is the caller graph for this function:

fortran_to_c_numbering()

template<typename MatrixType >

void Eigen::internal::fortran_to_c_numbering

(

MatrixType &

mat

)

  {
    // Check the Numbering
    if ( mat.outerIndexPtr()[0] == 1 ) 
    { // Convert to C-style numbering
      int i;
      for(i = 0; i <= mat.rows(); ++i)
        --mat.outerIndexPtr()[i];
      for(i = 0; i < mat.nonZeros(); ++i)
        --mat.innerIndexPtr()[i];
    }
  }

gebp_madd()

template<typename CJ , typename A , typename B , typename C , typename T >

EIGEN_STRONG_INLINE void Eigen::internal::gebp_madd	(	const CJ &	cj,
		A &	a,
		B &	b,
		C &	c,
		T &	t
	)

  {
    gebp_madd_selector<CJ,A,B,C,T>::run(cj,a,b,c,t);
  }

References Eigen::internal::gebp_madd_selector< CJ, A, B, C, T >::run().

Here is the call graph for this function:

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

{
  return matrix.coeff(i1,j1)
         * (matrix.coeff(i2,j2) * matrix.coeff(i3,j3) - matrix.coeff(i2,j3) * matrix.coeff(i3,j2));
}

Referenced by cofactor_4x4().

Here is the caller graph for this function:

generic_fast_tanh_float()

template<typename T >

T Eigen::internal::generic_fast_tanh_float

(

const T &

a_x

)

{
  // Clamp the inputs to the range [-9, 9] since anything outside
  // this range is +/-1.0f in single-precision.
  const T plus_9 = pset1<T>(9.f);
  const T minus_9 = pset1<T>(-9.f);
  // NOTE GCC prior to 6.3 might improperly optimize this max/min
  //      step such that if a_x is nan, x will be either 9 or -9,
  //      and tanh will return 1 or -1 instead of nan.
  //      This is supposed to be fixed in gcc6.3,
  //      see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
  const T x = pmax(minus_9,pmin(plus_9,a_x));
  // The monomial coefficients of the numerator polynomial (odd).
  const T alpha_1 = pset1<T>(4.89352455891786e-03f);
  const T alpha_3 = pset1<T>(6.37261928875436e-04f);
  const T alpha_5 = pset1<T>(1.48572235717979e-05f);
  const T alpha_7 = pset1<T>(5.12229709037114e-08f);
  const T alpha_9 = pset1<T>(-8.60467152213735e-11f);
  const T alpha_11 = pset1<T>(2.00018790482477e-13f);
  const T alpha_13 = pset1<T>(-2.76076847742355e-16f);
 
  // The monomial coefficients of the denominator polynomial (even).
  const T beta_0 = pset1<T>(4.89352518554385e-03f);
  const T beta_2 = pset1<T>(2.26843463243900e-03f);
  const T beta_4 = pset1<T>(1.18534705686654e-04f);
  const T beta_6 = pset1<T>(1.19825839466702e-06f);
 
  // Since the polynomials are odd/even, we need x^2.
  const T x2 = pmul(x, x);
 
  // Evaluate the numerator polynomial p.
  T p = pmadd(x2, alpha_13, alpha_11);
  p = pmadd(x2, p, alpha_9);
  p = pmadd(x2, p, alpha_7);
  p = pmadd(x2, p, alpha_5);
  p = pmadd(x2, p, alpha_3);
  p = pmadd(x2, p, alpha_1);
  p = pmul(x, p);
 
  // Evaluate the denominator polynomial p.
  T q = pmadd(x2, beta_6, beta_4);
  q = pmadd(x2, q, beta_2);
  q = pmadd(x2, q, beta_0);
 
  // Divide the numerator by the denominator.
  return pdiv(p, q);
}

References pdiv(), pmadd(), pmax(), pmin(), and pmul().

Referenced by ptanh< Packet4f >(), and ptanh< Packet8f >().

Here is the call graph for this function:

Here is the caller graph for this function:

GetMarketLine() [1/2]

template<typename Scalar , typename IndexType >

bool Eigen::internal::GetMarketLine ( std::stringstream &  line, IndexType &  M, IndexType &  N, IndexType &  i, IndexType &  j, Scalar &  value  )

inline

  {
    line >> i >> j >> value;
    i--;
    j--;
    if(i>=0 && j>=0 && i<M && j<N)
    {
      return true; 
    }
    else
      return false;
  }

Referenced by Eigen::loadMarket().

Here is the caller graph for this function:

GetMarketLine() [2/2]

template<typename Scalar , typename IndexType >

bool Eigen::internal::GetMarketLine ( std::stringstream &  line, IndexType &  M, IndexType &  N, IndexType &  i, IndexType &  j, std::complex< Scalar > &  value  )

inline

  {
    Scalar valR, valI;
    line >> i >> j >> valR >> valI;
    i--;
    j--;
    if(i>=0 && j>=0 && i<M && j<N)
    {
      value = std::complex<Scalar>(valR, valI);
      return true; 
    }
    else
      return false;
  }

GetVectorElt() [1/2]

template<typename RealScalar >

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

inline

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

Referenced by Eigen::loadMarketVector().

Here is the caller graph for this function:

GetVectorElt() [2/2]

template<typename RealScalar >

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

inline

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

handmade_aligned_free()

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

inline

{
  if (ptr) std::free(*(reinterpret_cast<void**>(ptr) - 1));
}

Referenced by aligned_free().

Here is the caller graph for this function:

handmade_aligned_malloc()

void * Eigen::internal::handmade_aligned_malloc ( std::size_t  size )

inline

{
  void *original = std::malloc(size+EIGEN_DEFAULT_ALIGN_BYTES);
  if (original == 0) return 0;
  void *aligned = reinterpret_cast<void*>((reinterpret_cast<std::size_t>(original) & ~(std::size_t(EIGEN_DEFAULT_ALIGN_BYTES-1))) + EIGEN_DEFAULT_ALIGN_BYTES);
  *(reinterpret_cast<void**>(aligned) - 1) = original;
  return aligned;
}

References EIGEN_DEFAULT_ALIGN_BYTES.

Referenced by aligned_malloc(), and handmade_aligned_realloc().

Here is the caller graph for this function:

handmade_aligned_realloc()

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

inline

{
  if (ptr == 0) return handmade_aligned_malloc(size);
  void *original = *(reinterpret_cast<void**>(ptr) - 1);
  std::ptrdiff_t previous_offset = static_cast<char *>(ptr)-static_cast<char *>(original);
  original = std::realloc(original,size+EIGEN_DEFAULT_ALIGN_BYTES);
  if (original == 0) return 0;
  void *aligned = reinterpret_cast<void*>((reinterpret_cast<std::size_t>(original) & ~(std::size_t(EIGEN_DEFAULT_ALIGN_BYTES-1))) + EIGEN_DEFAULT_ALIGN_BYTES);
  void *previous_aligned = static_cast<char *>(original)+previous_offset;
  if(aligned!=previous_aligned)
    std::memmove(aligned, previous_aligned, size);
  
  *(reinterpret_cast<void**>(aligned) - 1) = original;
  return aligned;
}

References EIGEN_DEFAULT_ALIGN_BYTES, and handmade_aligned_malloc().

Referenced by aligned_realloc().

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

{
  typedef typename MatrixQR::Scalar Scalar;
  typedef typename MatrixQR::RealScalar RealScalar;
  Index rows = mat.rows();
  Index cols = mat.cols();
  Index size = (std::min)(rows,cols);
 
  eigen_assert(hCoeffs.size() == size);
 
  typedef Matrix<Scalar,MatrixQR::ColsAtCompileTime,1> TempType;
  TempType tempVector;
  if(tempData==0)
  {
    tempVector.resize(cols);
    tempData = tempVector.data();
  }
 
  for(Index k = 0; k < size; ++k)
  {
    Index remainingRows = rows - k;
    Index remainingCols = cols - k - 1;
 
    RealScalar beta;
    mat.col(k).tail(remainingRows).makeHouseholderInPlace(hCoeffs.coeffRef(k), beta);
    mat.coeffRef(k,k) = beta;
 
    // apply H to remaining part of m_qr from the left
    mat.bottomRightCorner(remainingRows, remainingCols)
        .applyHouseholderOnTheLeft(mat.col(k).tail(remainingRows-1), hCoeffs.coeffRef(k), tempData+k+1);
  }
}

References eigen_assert, and Eigen::PlainObjectBase< Derived >::resize().

Referenced by Eigen::internal::householder_qr_inplace_blocked< MatrixQR, HCoeffs, MatrixQRScalar, InnerStrideIsOne >::run().

Here is the call graph for this function:

Here is the caller graph for this function:

ignore_unused_variable()

template<typename T >

EIGEN_DEVICE_FUNC void Eigen::internal::ignore_unused_variable

(

const T &

)

{}

is_same_dense() [1/2]

template<typename T1 , typename T2 >

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

{
  return false;
}

is_same_dense() [2/2]

template<typename T1 , typename T2 >

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

{
  return (mat1.data()==mat2.data()) && (mat1.innerStride()==mat2.innerStride()) && (mat1.outerStride()==mat2.outerStride());
}

Referenced by Eigen::LLT< _MatrixType, _UpLo >::compute(), Eigen::internal::triangular_solve_retval< Side, TriangularType, Rhs >::evalTo(), Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::evalTo(), Eigen::internal::permutation_matrix_product< ExpressionType, Side, Transposed, DenseShape >::run(), and Eigen::internal::transposition_matrix_product< ExpressionType, Side, Transposed, ExpressionShape >::run().

Here is the caller graph for this function:

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

{
  return scalar_fuzzy_impl<Scalar>::isApprox(x, y, precision);
}

References y.

Referenced by Eigen::AngleAxis< _Scalar >::isApprox(), Eigen::Rotation2D< _Scalar >::isApprox(), Eigen::UniformScaling< _Scalar >::isApprox(), Eigen::internal::scalar_fuzzy_default_impl< Scalar, false, false >::isApproxOrLessThan(), Eigen::DenseBase< Derived >::isApproxToConstant(), Eigen::MatrixBase< Derived >::isIdentity(), and Eigen::MatrixBase< Derived >::isUnitary().

Here is the caller graph for this function:

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

{
  return scalar_fuzzy_impl<Scalar>::isApproxOrLessThan(x, y, precision);
}

References y.

isfinite_impl() [1/3]

template<typename T >

EIGEN_DEVICE_FUNC bool Eigen::internal::isfinite_impl

(

const std::complex< T > &

x

)

{
  return (numext::isfinite)(numext::real(x)) && (numext::isfinite)(numext::imag(x));
}

References Eigen::numext::isfinite().

Here is the call graph for this function:

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 &

)

{ return true; }

Referenced by Eigen::numext::isfinite().

Here is the caller graph for this function:

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

)

{
  #ifdef __CUDA_ARCH__
    return (::isfinite)(x);
  #elif EIGEN_USE_STD_FPCLASSIFY
    using std::isfinite;
    return isfinite EIGEN_NOT_A_MACRO (x);
  #else
    return x<=NumTraits<T>::highest() && x>=NumTraits<T>::lowest();
  #endif
}

References EIGEN_NOT_A_MACRO.

isinf_impl() [1/3]

template<typename T >

EIGEN_DEVICE_FUNC bool Eigen::internal::isinf_impl

(

const std::complex< T > &

x

)

{
  return ((numext::isinf)(numext::real(x)) || (numext::isinf)(numext::imag(x))) && (!(numext::isnan)(x));
}

References Eigen::numext::isinf(), and Eigen::numext::isnan().

Here is the call graph for this function:

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 &

)

{ return false; }

Referenced by Eigen::numext::isinf().

Here is the caller graph for this function:

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

)

{
  #ifdef __CUDA_ARCH__
    return (::isinf)(x);
  #elif EIGEN_USE_STD_FPCLASSIFY
    using std::isinf;
    return isinf EIGEN_NOT_A_MACRO (x);
  #else
    return x>NumTraits<T>::highest() || x<NumTraits<T>::lowest();
  #endif
}

References EIGEN_NOT_A_MACRO.

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

{
  return scalar_fuzzy_impl<Scalar>::template isMuchSmallerThan<OtherScalar>(x, y, precision);
}

References y.

Referenced by computeFromTridiagonal_impl(), Eigen::FullPivHouseholderQR< _MatrixType >::computeInPlace(), Eigen::EigenSolver< _MatrixType >::eigenvectors(), Eigen::Hyperplane< _Scalar, _AmbientDim, _Options >::intersection(), Eigen::MatrixBase< Derived >::isDiagonal(), Eigen::MatrixBase< Derived >::isIdentity(), Eigen::MatrixBase< Derived >::isUnitary(), Eigen::DenseBase< Derived >::isZero(), Eigen::internal::CompressedStorage< _Scalar, _StorageIndex >::prune(), Eigen::EigenSolver< _MatrixType >::pseudoEigenvalueMatrix(), and Eigen::internal::unitOrthogonal_selector< Derived, 3 >::run().

Here is the caller graph for this function:

isnan_impl() [1/3]

template<typename T >

EIGEN_DEVICE_FUNC bool Eigen::internal::isnan_impl

(

const std::complex< T > &

x

)

{
  return (numext::isnan)(numext::real(x)) || (numext::isnan)(numext::imag(x));
}

References Eigen::numext::isnan().

Here is the call graph for this function:

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 &

)

{ return false; }

Referenced by Eigen::numext::isnan().

Here is the caller graph for this function:

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

)

{
  #ifdef __CUDA_ARCH__
    return (::isnan)(x);
  #elif EIGEN_USE_STD_FPCLASSIFY
    using std::isnan;
    return isnan EIGEN_NOT_A_MACRO (x);
  #else
    return x != x;
  #endif
}

References EIGEN_NOT_A_MACRO.

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
	)

{
  using std::sqrt;
  using std::abs;
  typedef typename Dest::RealScalar RealScalar;
  typedef typename Dest::Scalar Scalar;
  typedef Matrix<Scalar,Dynamic,1> VectorType;
  
  RealScalar tol = tol_error;
  Index maxIters = iters;
  
  Index m = mat.rows(), n = mat.cols();
 
  VectorType residual        = rhs - mat * x;
  VectorType normal_residual = mat.adjoint() * residual;
 
  RealScalar rhsNorm2 = (mat.adjoint()*rhs).squaredNorm();
  if(rhsNorm2 == 0) 
  {
    x.setZero();
    iters = 0;
    tol_error = 0;
    return;
  }
  RealScalar threshold = tol*tol*rhsNorm2;
  RealScalar residualNorm2 = normal_residual.squaredNorm();
  if (residualNorm2 < threshold)
  {
    iters = 0;
    tol_error = sqrt(residualNorm2 / rhsNorm2);
    return;
  }
  
  VectorType p(n);
  p = precond.solve(normal_residual);                         // initial search direction
 
  VectorType z(n), tmp(m);
  RealScalar absNew = numext::real(normal_residual.dot(p));  // the square of the absolute value of r scaled by invM
  Index i = 0;
  while(i < maxIters)
  {
    tmp.noalias() = mat * p;
 
    Scalar alpha = absNew / tmp.squaredNorm();      // the amount we travel on dir
    x += alpha * p;                                 // update solution
    residual -= alpha * tmp;                        // update residual
    normal_residual = mat.adjoint() * residual;     // update residual of the normal equation
    
    residualNorm2 = normal_residual.squaredNorm();
    if(residualNorm2 < threshold)
      break;
    
    z = precond.solve(normal_residual);             // approximately solve for "A'A z = normal_residual"
 
    RealScalar absOld = absNew;
    absNew = numext::real(normal_residual.dot(z));  // update the absolute value of r
    RealScalar beta = absNew / absOld;              // calculate the Gram-Schmidt value used to create the new search direction
    p = z + beta * p;                               // update search direction
    i++;
  }
  tol_error = sqrt(residualNorm2 / rhsNorm2);
  iters = i;
}

References Eigen::PlainObjectBase< Derived >::rows(), and sqrt().

Referenced by Eigen::LeastSquaresConjugateGradient< _MatrixType, _Preconditioner >::_solve_with_guess_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

llt_rank_update_lower()

template<typename MatrixType , typename VectorType >

static Index Eigen::internal::llt_rank_update_lower ( MatrixType &  mat, const VectorType &  vec, const typename MatrixType::RealScalar &  sigma  )

static

{
  using std::sqrt;
  typedef typename MatrixType::Scalar Scalar;
  typedef typename MatrixType::RealScalar RealScalar;
  typedef typename MatrixType::ColXpr ColXpr;
  typedef typename internal::remove_all<ColXpr>::type ColXprCleaned;
  typedef typename ColXprCleaned::SegmentReturnType ColXprSegment;
  typedef Matrix<Scalar,Dynamic,1> TempVectorType;
  typedef typename TempVectorType::SegmentReturnType TempVecSegment;
 
  Index n = mat.cols();
  eigen_assert(mat.rows()==n && vec.size()==n);
 
  TempVectorType temp;
 
  if(sigma>0)
  {
    // This version is based on Givens rotations.
    // It is faster than the other one below, but only works for updates,
    // i.e., for sigma > 0
    temp = sqrt(sigma) * vec;
 
    for(Index i=0; i<n; ++i)
    {
      JacobiRotation<Scalar> g;
      g.makeGivens(mat(i,i), -temp(i), &mat(i,i));
 
      Index rs = n-i-1;
      if(rs>0)
      {
        ColXprSegment x(mat.col(i).tail(rs));
        TempVecSegment y(temp.tail(rs));
        apply_rotation_in_the_plane(x, y, g);
      }
    }
  }
  else
  {
    temp = vec;
    RealScalar beta = 1;
    for(Index j=0; j<n; ++j)
    {
      RealScalar Ljj = numext::real(mat.coeff(j,j));
      RealScalar dj = numext::abs2(Ljj);
      Scalar wj = temp.coeff(j);
      RealScalar swj2 = sigma*numext::abs2(wj);
      RealScalar gamma = dj*beta + swj2;
 
      RealScalar x = dj + swj2/beta;
      if (x<=RealScalar(0))
        return j;
      RealScalar nLjj = sqrt(x);
      mat.coeffRef(j,j) = nLjj;
      beta += swj2/dj;
 
      // Update the terms of L
      Index rs = n-j-1;
      if(rs)
      {
        temp.tail(rs) -= (wj/Ljj) * mat.col(j).tail(rs);
        if(gamma != 0)
          mat.col(j).tail(rs) = (nLjj/Ljj) * mat.col(j).tail(rs) + (nLjj * sigma*numext::conj(wj)/gamma)*temp.tail(rs);
      }
    }
  }
  return -1;
}

References apply_rotation_in_the_plane(), Eigen::PlainObjectBase< Derived >::cols(), eigen_assert, Eigen::JacobiRotation< Scalar >::makeGivens(), sqrt(), and y.

Referenced by Eigen::internal::llt_inplace< Scalar, Lower >::rankUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

LUnumTempV()

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

inline

{
  return (std::max)(m, (t+b)*w);
}

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::factorize().

Here is the caller graph for this function:

LUTempSpace()

template<typename Scalar >

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

inline

{
  return (2*w + 4 + LUNoMarker) * m * sizeof(Index) + (w + 1) * m * sizeof(Scalar);
}

References LUNoMarker.

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
	)

{
  const Index nbVecs = vectors.cols();
  eigen_assert(triFactor.rows() == nbVecs && triFactor.cols() == nbVecs && vectors.rows()>=nbVecs);
 
  for(Index i = nbVecs-1; i >=0 ; --i)
  {
    Index rs = vectors.rows() - i - 1;
    Index rt = nbVecs-i-1;
 
    if(rt>0)
    {
      triFactor.row(i).tail(rt).noalias() = -hCoeffs(i) * vectors.col(i).tail(rs).adjoint()
                                                        * vectors.bottomRightCorner(rs, rt).template triangularView<UnitLower>();
            
      // FIXME add .noalias() once the triangular product can work inplace
      triFactor.row(i).tail(rt) = triFactor.row(i).tail(rt) * triFactor.bottomRightCorner(rt,rt).template triangularView<Upper>();
      
    }
    triFactor(i,i) = hCoeffs(i);
  }
}

References eigen_assert.

Referenced by apply_block_householder_on_the_left().

Here is the caller graph for this function:

manage_caching_sizes()

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

inline

{
  static CacheSizes m_cacheSizes;
 
  if(action==SetAction)
  {
    // set the cpu cache size and cache all block sizes from a global cache size in byte
    eigen_internal_assert(l1!=0 && l2!=0);
    m_cacheSizes.m_l1 = *l1;
    m_cacheSizes.m_l2 = *l2;
    m_cacheSizes.m_l3 = *l3;
  }
  else if(action==GetAction)
  {
    eigen_internal_assert(l1!=0 && l2!=0);
    *l1 = m_cacheSizes.m_l1;
    *l2 = m_cacheSizes.m_l2;
    *l3 = m_cacheSizes.m_l3;
  }
  else
  {
    eigen_internal_assert(false);
  }
}

References eigen_internal_assert, Eigen::GetAction, Eigen::internal::CacheSizes::m_l1, Eigen::internal::CacheSizes::m_l2, Eigen::internal::CacheSizes::m_l3, and Eigen::SetAction.

Referenced by evaluateProductBlockingSizesHeuristic(), Eigen::initParallel(), Eigen::l1CacheSize(), Eigen::l2CacheSize(), Eigen::l3CacheSize(), Eigen::internal::triangular_solve_matrix< Scalar, Index, OnTheLeft, Mode, Conjugate, TriStorageOrder, ColMajor >::run(), and Eigen::setCpuCacheSizes().

Here is the caller graph for this function:

manage_caching_sizes_helper()

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

inline

{
  return a<=0 ? b : a;
}

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

Here is the caller graph for this function:

manage_multi_threading()

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

inline

{
  static EIGEN_UNUSED int m_maxThreads = -1;
 
  if(action==SetAction)
  {
    eigen_internal_assert(v!=0);
    m_maxThreads = *v;
  }
  else if(action==GetAction)
  {
    eigen_internal_assert(v!=0);
    #ifdef EIGEN_HAS_OPENMP
    if(m_maxThreads>0)
      *v = m_maxThreads;
    else
      *v = omp_get_max_threads();
    #else
    *v = 1;
    #endif
  }
  else
  {
    eigen_internal_assert(false);
  }
}

References eigen_internal_assert, EIGEN_UNUSED, Eigen::GetAction, and Eigen::SetAction.

Referenced by Eigen::initParallel(), Eigen::nbThreads(), and Eigen::setNbThreads().

Here is the caller graph for this function:

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

{
  eigen_assert(((Flags&RowMajor)==RowMajor && sluMat.Stype == SLU_NR)
         || ((Flags&ColMajor)==ColMajor && sluMat.Stype == SLU_NC));
 
  Index outerSize = (Flags&RowMajor)==RowMajor ? sluMat.ncol : sluMat.nrow;
 
  return MappedSparseMatrix<Scalar,Flags,Index>(
    sluMat.nrow, sluMat.ncol, sluMat.storage.outerInd[outerSize],
    sluMat.storage.outerInd, sluMat.storage.innerInd, reinterpret_cast<Scalar*>(sluMat.storage.values) );
}

References Eigen::ColMajor, eigen_assert, Eigen::RowMajor, and Eigen::SluMatrix::storage.

minimum_degree_ordering()

template<typename Scalar , typename StorageIndex >

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

{
  using std::sqrt;
  
  StorageIndex d, dk, dext, lemax = 0, e, elenk, eln, i, j, k, k1,
                k2, k3, jlast, ln, dense, nzmax, mindeg = 0, nvi, nvj, nvk, mark, wnvi,
                ok, nel = 0, p, p1, p2, p3, p4, pj, pk, pk1, pk2, pn, q, t, h;
  
  StorageIndex n = StorageIndex(C.cols());
  dense = std::max<StorageIndex> (16, StorageIndex(10 * sqrt(double(n))));   /* find dense threshold */
  dense = (std::min)(n-2, dense);
  
  StorageIndex cnz = StorageIndex(C.nonZeros());
  perm.resize(n+1);
  t = cnz + cnz/5 + 2*n;                 /* add elbow room to C */
  C.resizeNonZeros(t);
  
  // get workspace
  ei_declare_aligned_stack_constructed_variable(StorageIndex,W,8*(n+1),0);
  StorageIndex* len     = W;
  StorageIndex* nv      = W +   (n+1);
  StorageIndex* next    = W + 2*(n+1);
  StorageIndex* head    = W + 3*(n+1);
  StorageIndex* elen    = W + 4*(n+1);
  StorageIndex* degree  = W + 5*(n+1);
  StorageIndex* w       = W + 6*(n+1);
  StorageIndex* hhead   = W + 7*(n+1);
  StorageIndex* last    = perm.indices().data();                              /* use P as workspace for last */
  
  /* --- Initialize quotient graph ---------------------------------------- */
  StorageIndex* Cp = C.outerIndexPtr();
  StorageIndex* Ci = C.innerIndexPtr();
  for(k = 0; k < n; k++)
    len[k] = Cp[k+1] - Cp[k];
  len[n] = 0;
  nzmax = t;
  
  for(i = 0; i <= n; i++)
  {
    head[i]   = -1;                     // degree list i is empty
    last[i]   = -1;
    next[i]   = -1;
    hhead[i]  = -1;                     // hash list i is empty 
    nv[i]     = 1;                      // node i is just one node
    w[i]      = 1;                      // node i is alive
    elen[i]   = 0;                      // Ek of node i is empty
    degree[i] = len[i];                 // degree of node i
  }
  mark = internal::cs_wclear<StorageIndex>(0, 0, w, n);         /* clear w */
  
  /* --- Initialize degree lists ------------------------------------------ */
  for(i = 0; i < n; i++)
  {
    bool has_diag = false;
    for(p = Cp[i]; p<Cp[i+1]; ++p)
      if(Ci[p]==i)
      {
        has_diag = true;
        break;
      }
   
    d = degree[i];
    if(d == 1 && has_diag)           /* node i is empty */
    {
      elen[i] = -2;                 /* element i is dead */
      nel++;
      Cp[i] = -1;                   /* i is a root of assembly tree */
      w[i] = 0;
    }
    else if(d > dense || !has_diag)  /* node i is dense or has no structural diagonal element */
    {
      nv[i] = 0;                    /* absorb i into element n */
      elen[i] = -1;                 /* node i is dead */
      nel++;
      Cp[i] = amd_flip (n);
      nv[n]++;
    }
    else
    {
      if(head[d] != -1) last[head[d]] = i;
      next[i] = head[d];           /* put node i in degree list d */
      head[d] = i;
    }
  }
  
  elen[n] = -2;                         /* n is a dead element */
  Cp[n] = -1;                           /* n is a root of assembly tree */
  w[n] = 0;                             /* n is a dead element */
  
  while (nel < n)                         /* while (selecting pivots) do */
  {
    /* --- Select node of minimum approximate degree -------------------- */
    for(k = -1; mindeg < n && (k = head[mindeg]) == -1; mindeg++) {}
    if(next[k] != -1) last[next[k]] = -1;
    head[mindeg] = next[k];          /* remove k from degree list */
    elenk = elen[k];                  /* elenk = |Ek| */
    nvk = nv[k];                      /* # of nodes k represents */
    nel += nvk;                        /* nv[k] nodes of A eliminated */
    
    /* --- Garbage collection ------------------------------------------- */
    if(elenk > 0 && cnz + mindeg >= nzmax)
    {
      for(j = 0; j < n; j++)
      {
        if((p = Cp[j]) >= 0)      /* j is a live node or element */
        {
          Cp[j] = Ci[p];          /* save first entry of object */
          Ci[p] = amd_flip (j);    /* first entry is now amd_flip(j) */
        }
      }
      for(q = 0, p = 0; p < cnz; ) /* scan all of memory */
      {
        if((j = amd_flip (Ci[p++])) >= 0)  /* found object j */
        {
          Ci[q] = Cp[j];       /* restore first entry of object */
          Cp[j] = q++;          /* new pointer to object j */
          for(k3 = 0; k3 < len[j]-1; k3++) Ci[q++] = Ci[p++];
        }
      }
      cnz = q;                       /* Ci[cnz...nzmax-1] now free */
    }
    
    /* --- Construct new element ---------------------------------------- */
    dk = 0;
    nv[k] = -nvk;                     /* flag k as in Lk */
    p = Cp[k];
    pk1 = (elenk == 0) ? p : cnz;      /* do in place if elen[k] == 0 */
    pk2 = pk1;
    for(k1 = 1; k1 <= elenk + 1; k1++)
    {
      if(k1 > elenk)
      {
        e = k;                     /* search the nodes in k */
        pj = p;                    /* list of nodes starts at Ci[pj]*/
        ln = len[k] - elenk;      /* length of list of nodes in k */
      }
      else
      {
        e = Ci[p++];              /* search the nodes in e */
        pj = Cp[e];
        ln = len[e];              /* length of list of nodes in e */
      }
      for(k2 = 1; k2 <= ln; k2++)
      {
        i = Ci[pj++];
        if((nvi = nv[i]) <= 0) continue; /* node i dead, or seen */
        dk += nvi;                 /* degree[Lk] += size of node i */
        nv[i] = -nvi;             /* negate nv[i] to denote i in Lk*/
        Ci[pk2++] = i;            /* place i in Lk */
        if(next[i] != -1) last[next[i]] = last[i];
        if(last[i] != -1)         /* remove i from degree list */
        {
          next[last[i]] = next[i];
        }
        else
        {
          head[degree[i]] = next[i];
        }
      }
      if(e != k)
      {
        Cp[e] = amd_flip (k);      /* absorb e into k */
        w[e] = 0;                 /* e is now a dead element */
      }
    }
    if(elenk != 0) cnz = pk2;         /* Ci[cnz...nzmax] is free */
    degree[k] = dk;                   /* external degree of k - |Lk\i| */
    Cp[k] = pk1;                      /* element k is in Ci[pk1..pk2-1] */
    len[k] = pk2 - pk1;
    elen[k] = -2;                     /* k is now an element */
    
    /* --- Find set differences ----------------------------------------- */
    mark = internal::cs_wclear<StorageIndex>(mark, lemax, w, n);  /* clear w if necessary */
    for(pk = pk1; pk < pk2; pk++)    /* scan 1: find |Le\Lk| */
    {
      i = Ci[pk];
      if((eln = elen[i]) <= 0) continue;/* skip if elen[i] empty */
      nvi = -nv[i];                      /* nv[i] was negated */
      wnvi = mark - nvi;
      for(p = Cp[i]; p <= Cp[i] + eln - 1; p++)  /* scan Ei */
      {
        e = Ci[p];
        if(w[e] >= mark)
        {
          w[e] -= nvi;          /* decrement |Le\Lk| */
        }
        else if(w[e] != 0)        /* ensure e is a live element */
        {
          w[e] = degree[e] + wnvi; /* 1st time e seen in scan 1 */
        }
      }
    }
    
    /* --- Degree update ------------------------------------------------ */
    for(pk = pk1; pk < pk2; pk++)    /* scan2: degree update */
    {
      i = Ci[pk];                   /* consider node i in Lk */
      p1 = Cp[i];
      p2 = p1 + elen[i] - 1;
      pn = p1;
      for(h = 0, d = 0, p = p1; p <= p2; p++)    /* scan Ei */
      {
        e = Ci[p];
        if(w[e] != 0)             /* e is an unabsorbed element */
        {
          dext = w[e] - mark;   /* dext = |Le\Lk| */
          if(dext > 0)
          {
            d += dext;         /* sum up the set differences */
            Ci[pn++] = e;     /* keep e in Ei */
            h += e;            /* compute the hash of node i */
          }
          else
          {
            Cp[e] = amd_flip (k);  /* aggressive absorb. e->k */
            w[e] = 0;             /* e is a dead element */
          }
        }
      }
      elen[i] = pn - p1 + 1;        /* elen[i] = |Ei| */
      p3 = pn;
      p4 = p1 + len[i];
      for(p = p2 + 1; p < p4; p++) /* prune edges in Ai */
      {
        j = Ci[p];
        if((nvj = nv[j]) <= 0) continue; /* node j dead or in Lk */
        d += nvj;                  /* degree(i) += |j| */
        Ci[pn++] = j;             /* place j in node list of i */
        h += j;                    /* compute hash for node i */
      }
      if(d == 0)                     /* check for mass elimination */
      {
        Cp[i] = amd_flip (k);      /* absorb i into k */
        nvi = -nv[i];
        dk -= nvi;                 /* |Lk| -= |i| */
        nvk += nvi;                /* |k| += nv[i] */
        nel += nvi;
        nv[i] = 0;
        elen[i] = -1;             /* node i is dead */
      }
      else
      {
        degree[i] = std::min<StorageIndex> (degree[i], d);   /* update degree(i) */
        Ci[pn] = Ci[p3];         /* move first node to end */
        Ci[p3] = Ci[p1];         /* move 1st el. to end of Ei */
        Ci[p1] = k;               /* add k as 1st element in of Ei */
        len[i] = pn - p1 + 1;     /* new len of adj. list of node i */
        h %= n;                    /* finalize hash of i */
        next[i] = hhead[h];      /* place i in hash bucket */
        hhead[h] = i;
        last[i] = h;      /* save hash of i in last[i] */
      }
    }                                   /* scan2 is done */
    degree[k] = dk;                   /* finalize |Lk| */
    lemax = std::max<StorageIndex>(lemax, dk);
    mark = internal::cs_wclear<StorageIndex>(mark+lemax, lemax, w, n);    /* clear w */
    
    /* --- Supernode detection ------------------------------------------ */
    for(pk = pk1; pk < pk2; pk++)
    {
      i = Ci[pk];
      if(nv[i] >= 0) continue;         /* skip if i is dead */
      h = last[i];                      /* scan hash bucket of node i */
      i = hhead[h];
      hhead[h] = -1;                    /* hash bucket will be empty */
      for(; i != -1 && next[i] != -1; i = next[i], mark++)
      {
        ln = len[i];
        eln = elen[i];
        for(p = Cp[i]+1; p <= Cp[i] + ln-1; p++) w[Ci[p]] = mark;
        jlast = i;
        for(j = next[i]; j != -1; ) /* compare i with all j */
        {
          ok = (len[j] == ln) && (elen[j] == eln);
          for(p = Cp[j] + 1; ok && p <= Cp[j] + ln - 1; p++)
          {
            if(w[Ci[p]] != mark) ok = 0;    /* compare i and j*/
          }
          if(ok)                     /* i and j are identical */
          {
            Cp[j] = amd_flip (i);  /* absorb j into i */
            nv[i] += nv[j];
            nv[j] = 0;
            elen[j] = -1;         /* node j is dead */
            j = next[j];          /* delete j from hash bucket */
            next[jlast] = j;
          }
          else
          {
            jlast = j;             /* j and i are different */
            j = next[j];
          }
        }
      }
    }
    
    /* --- Finalize new element------------------------------------------ */
    for(p = pk1, pk = pk1; pk < pk2; pk++)   /* finalize Lk */
    {
      i = Ci[pk];
      if((nvi = -nv[i]) <= 0) continue;/* skip if i is dead */
      nv[i] = nvi;                      /* restore nv[i] */
      d = degree[i] + dk - nvi;         /* compute external degree(i) */
      d = std::min<StorageIndex> (d, n - nel - nvi);
      if(head[d] != -1) last[head[d]] = i;
      next[i] = head[d];               /* put i back in degree list */
      last[i] = -1;
      head[d] = i;
      mindeg = std::min<StorageIndex> (mindeg, d);       /* find new minimum degree */
      degree[i] = d;
      Ci[p++] = i;                      /* place i in Lk */
    }
    nv[k] = nvk;                      /* # nodes absorbed into k */
    if((len[k] = p-pk1) == 0)         /* length of adj list of element k*/
    {
      Cp[k] = -1;                   /* k is a root of the tree */
      w[k] = 0;                     /* k is now a dead element */
    }
    if(elenk != 0) cnz = p;           /* free unused space in Lk */
  }
  
  /* --- Postordering ----------------------------------------------------- */
  for(i = 0; i < n; i++) Cp[i] = amd_flip (Cp[i]);/* fix assembly tree */
  for(j = 0; j <= n; j++) head[j] = -1;
  for(j = n; j >= 0; j--)              /* place unordered nodes in lists */
  {
    if(nv[j] > 0) continue;          /* skip if j is an element */
    next[j] = head[Cp[j]];          /* place j in list of its parent */
    head[Cp[j]] = j;
  }
  for(e = n; e >= 0; e--)              /* place elements in lists */
  {
    if(nv[e] <= 0) continue;         /* skip unless e is an element */
    if(Cp[e] != -1)
    {
      next[e] = head[Cp[e]];      /* place e in list of its parent */
      head[Cp[e]] = e;
    }
  }
  for(k = 0, i = 0; i <= n; i++)       /* postorder the assembly tree */
  {
    if(Cp[i] == -1) k = internal::cs_tdfs<StorageIndex>(i, k, head, next, perm.indices().data(), w);
  }
  
  perm.indices().conservativeResize(n);
}

References amd_flip(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::cols(), ei_declare_aligned_stack_constructed_variable, head(), Eigen::PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex >::indices(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::innerIndexPtr(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::nonZeros(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::outerIndexPtr(), Eigen::PermutationBase< Derived >::resize(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::resizeNonZeros(), and sqrt().

Referenced by Eigen::AMDOrdering< StorageIndex >::operator()(), and Eigen::AMDOrdering< StorageIndex >::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

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.

{
  typedef typename IndexVector::Scalar StorageIndex;
  StorageIndex current = n, first, next;
  while (postnum != n) 
  {
    // No kid for the current node
    first = first_kid(current);
    
    // no kid for the current node
    if (first == -1) 
    {
      // Numbering this node because it has no kid 
      post(current) = postnum++;
      
      // looking for the next kid 
      next = next_kid(current); 
      while (next == -1) 
      {
        // No more kids : back to the parent node
        current = parent(current); 
        // numbering the parent node 
        post(current) = postnum++;
        
        // Get the next kid 
        next = next_kid(current); 
      }
      // stopping criterion 
      if (postnum == n+1) return; 
      
      // Updating current node 
      current = next; 
    }
    else 
    {
      current = first; 
    }
  }
}

Referenced by treePostorder().

Here is the caller graph for this function:

operator<<() [1/7]

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

inline

{
  union {
    Packet16uc   v;
    unsigned char n[16];
  } vt;
  vt.v = v;
  for (int i=0; i< 16; i++)
    s << (int)vt.n[i] << ", ";
  return s;
}

operator<<() [2/7]

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

inline

{
  Packet vt;
  vt.v2d = v;
  s << vt.d[0] << ", " << vt.d[1];
  return s;
}

References Eigen::internal::Packet::d, and Eigen::internal::Packet::v2d.

operator<<() [3/7]

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

inline

{
  Packet vt;
  vt.v2l = v;
  s << vt.l[0] << ", " << vt.l[1];
  return s;
}

References Eigen::internal::Packet::l, and Eigen::internal::Packet::v2l.

operator<<() [4/7]

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

inline

{
  Packet vt;
  vt.v2ul = v;
  s << vt.ul[0] << ", " << vt.ul[1] ;
  return s;
}

References Eigen::internal::Packet::ul, and Eigen::internal::Packet::v2ul.

operator<<() [5/7]

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

inline

{
  union {
    Packet4f   v;
    float n[4];
  } vt;
  vt.v = v;
  s << vt.n[0] << ", " << vt.n[1] << ", " << vt.n[2] << ", " << vt.n[3];
  return s;
}

operator<<() [6/7]

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

inline

{
  union {
    Packet4i   v;
    int n[4];
  } vt;
  vt.v = v;
  s << vt.n[0] << ", " << vt.n[1] << ", " << vt.n[2] << ", " << vt.n[3];
  return s;
}

operator<<() [7/7]

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

inline

{
  union {
    Packet4ui   v;
    unsigned int n[4];
  } vt;
  vt.v = v;
  s << vt.n[0] << ", " << vt.n[1] << ", " << vt.n[2] << ", " << vt.n[3];
  return s;
}

ordering_helper_at_plus_a()

template<typename MatrixType >

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

{
  MatrixType C;
  C = A.transpose(); // NOTE: Could be  costly
  for (int i = 0; i < C.rows(); i++) 
  {
      for (typename MatrixType::InnerIterator it(C, i); it; ++it)
        it.valueRef() = 0.0;
  }
  symmat = C + A;
}

Referenced by Eigen::AMDOrdering< StorageIndex >::operator()().

Here is the caller graph for this function:

outer_product_selector_run() [1/2]

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

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

{
  evaluator<Rhs> rhsEval(rhs);
  typename nested_eval<Lhs,Rhs::SizeAtCompileTime>::type actual_lhs(lhs);
  // FIXME if cols is large enough, then it might be useful to make sure that lhs is sequentially stored
  // FIXME not very good if rhs is real and lhs complex while alpha is real too
  const Index cols = dst.cols();
  for (Index j=0; j<cols; ++j)
    func(dst.col(j), rhsEval.coeff(Index(0),j) * actual_lhs);
}

Referenced by Eigen::internal::generic_product_impl< Lhs, Rhs, DenseShape, DenseShape, OuterProduct >::addTo(), Eigen::internal::generic_product_impl< Lhs, Rhs, DenseShape, DenseShape, OuterProduct >::evalTo(), Eigen::internal::generic_product_impl< Lhs, Rhs, DenseShape, DenseShape, OuterProduct >::scaleAndAddTo(), and Eigen::internal::generic_product_impl< Lhs, Rhs, DenseShape, DenseShape, OuterProduct >::subTo().

Here is the caller graph for this function:

outer_product_selector_run() [2/2]

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

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

{
  evaluator<Lhs> lhsEval(lhs);
  typename nested_eval<Rhs,Lhs::SizeAtCompileTime>::type actual_rhs(rhs);
  // FIXME if rows is large enough, then it might be useful to make sure that rhs is sequentially stored
  // FIXME not very good if lhs is real and rhs complex while alpha is real too
  const Index rows = dst.rows();
  for (Index i=0; i<rows; ++i)
    func(dst.row(i), lhsEval.coeff(i,Index(0)) * actual_rhs);
}

p2ui_CONJ_XOR()

uint32x2_t Eigen::internal::p2ui_CONJ_XOR ( )

inline

                                  {
  static const uint32_t conj_XOR_DATA[] = { 0x00000000, 0x80000000 };
  return vld1_u32( conj_XOR_DATA );
}

Referenced by predux_mul< Packet2cf >().

Here is the caller graph for this function:

pabs() [1/12]

template<typename Packet >

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

inline

{ using std::abs; return abs(a); }

pabs() [2/12]

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pabs

(

const Packet16f &

a

)

{
  // _mm512_abs_ps intrinsic not found, so hack around it
  return _mm512_castsi512_ps(_mm512_and_si512(_mm512_castps_si512(a), _mm512_set1_epi32(0x7fffffff)));
}

pabs() [3/12]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pabs

(

const Packet2d &

a

)

{
  const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF));
  return _mm_and_pd(a,mask);
}

pabs() [4/12]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pabs

(

const Packet4d &

a

)

{
  const Packet4d mask = _mm256_castsi256_pd(_mm256_setr_epi32(0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF));
  return _mm256_and_pd(a,mask);
}

pabs() [5/12]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pabs

(

const Packet4f &

a

)

{ return vec_abs(a); }

Referenced by pabs< Packet4f >(), Eigen::internal::scalar_abs_op< Scalar >::packetOp(), pcos< Packet4f >(), and psin< Packet4f >().

Here is the caller graph for this function:

pabs() [6/12]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pabs

(

const Packet4f &

a

)

{ return vabsq_f32(a); }

pabs() [7/12]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pabs

(

const Packet4f &

a

)

{
  const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF));
  return _mm_and_ps(a,mask);
}

pabs() [8/12]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pabs

(

const Packet4i &

a

)

{ return vec_abs(a); }

pabs() [9/12]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pabs

(

const Packet4i &

a

)

{ return vabsq_s32(a); }

pabs() [10/12]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pabs

(

const Packet4i &

a

)

{
  #ifdef EIGEN_VECTORIZE_SSSE3
  return _mm_abs_epi32(a);
  #else
  Packet4i aux = _mm_srai_epi32(a,31);
  return _mm_sub_epi32(_mm_xor_si128(a,aux),aux);
  #endif
}

pabs() [11/12]

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pabs

(

const Packet8d &

a

)

                                                     {
  // _mm512_abs_ps intrinsic not found, so hack around it
  return _mm512_castsi512_pd(_mm512_and_si512(_mm512_castpd_si512(a),
                                   _mm512_set1_epi64(0x7fffffffffffffff)));
}

pabs() [12/12]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pabs

(

const Packet8f &

a

)

{
  const Packet8f mask = _mm256_castsi256_ps(_mm256_setr_epi32(0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF));
  return _mm256_and_ps(a,mask);
}

pabs< Packet2d >()

template<>

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

(

const Packet2d &

a

)

{ return vec_abs(a); }

pabs< Packet4f >()

template<>

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

(

const Packet4f &

a

)

{
  Packet4f res;
  res.v4f[0] = pabs(a.v4f[0]);
  res.v4f[1] = pabs(a.v4f[1]);
  return res;
}

References pabs(), and Eigen::internal::Packet4f::v4f.

Here is the call graph for this function:

pabs< Packet4i >()

template<>

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

(

const Packet4i &

a

)

{ return vec_abs(a); }

pacos()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pacos

(

const Packet &

a

)

{ using std::acos; return acos(a); }

References acos().

Here is the call graph for this function:

padd() [1/2]

template<typename Packet >

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

{
  DoublePacket<Packet> res;
  res.first  = padd(a.first, b.first);
  res.second = padd(a.second,b.second);
  return res;
}

References Eigen::internal::DoublePacket< Packet >::first, padd(), and Eigen::internal::DoublePacket< Packet >::second.

Here is the call graph for this function:

padd() [2/2]

template<typename Packet >

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

inline

                         { return a+b; }

Referenced by Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs >::acc(), Eigen::internal::add_assign_op< DstScalar, SrcScalar >::assignPacket(), Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs >::madd(), Eigen::internal::gebp_traits< _LhsScalar, _RhsScalar, _ConjLhs, _ConjRhs >::madd(), Eigen::internal::gebp_traits< std::complex< RealScalar >, RealScalar, _ConjLhs, false >::madd_impl(), Eigen::internal::gebp_traits< RealScalar, std::complex< RealScalar >, false, _ConjRhs >::madd_impl(), Eigen::internal::gebp_kernel< LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >::operator()(), Eigen::internal::scalar_sum_op< LhsScalar, RhsScalar >::packetOp(), Eigen::internal::linspaced_op_impl< Scalar, Packet, false >::packetOp(), padd(), pcos< Packet4f >(), pexp< Packet4f >(), pexp< Packet8f >(), plog< Packet4f >(), plog< Packet8f >(), Eigen::internal::conj_helper< LhsScalar, RhsScalar, ConjLhs, ConjRhs >::pmadd(), pmadd(), Eigen::internal::conj_helper< Packet1cd, Packet1cd, false, true >::pmadd(), Eigen::internal::conj_helper< Packet1cd, Packet1cd, true, false >::pmadd(), Eigen::internal::conj_helper< Packet1cd, Packet1cd, true, true >::pmadd(), Eigen::internal::conj_helper< Packet2cd, Packet2cd, false, true >::pmadd(), Eigen::internal::conj_helper< Packet2cd, Packet2cd, true, false >::pmadd(), Eigen::internal::conj_helper< Packet2cd, Packet2cd, true, true >::pmadd(), Eigen::internal::conj_helper< Packet2cf, Packet2cf, false, true >::pmadd(), Eigen::internal::conj_helper< Packet2cf, Packet2cf, true, false >::pmadd(), Eigen::internal::conj_helper< Packet2cf, Packet2cf, true, true >::pmadd(), Eigen::internal::conj_helper< Packet4cf, Packet4cf, false, true >::pmadd(), Eigen::internal::conj_helper< Packet4cf, Packet4cf, true, false >::pmadd(), Eigen::internal::conj_helper< Packet4cf, Packet4cf, true, true >::pmadd(), pmadd(), Eigen::internal::conj_helper< RealScalar, std::complex< RealScalar >, false, Conj >::pmadd(), Eigen::internal::conj_helper< std::complex< RealScalar >, RealScalar, Conj, false >::pmadd(), predux< Packet16f >(), predux< Packet2cd >(), predux< Packet4cf >(), predux< Packet8d >(), predux_downto4< Packet16f >(), predux_downto4< Packet8d >(), preduxp< Packet16f >(), preduxp< Packet4f >(), preduxp< Packet8d >(), psin< Packet4f >(), psin< Packet8f >(), Eigen::internal::gebp_madd_selector< CJ, T, T, T, T >::run(), Eigen::internal::quat_product< Architecture::SSE, Derived, OtherDerived, double >::run(), and Eigen::internal::apply_rotation_in_the_plane_selector< Scalar, OtherScalar, SizeAtCompileTime, MinAlignment, true >::run().

Here is the caller graph for this function:

padd< Packet16f >()

template<>

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

                                                                  {
  return _mm512_add_ps(a, b);
}

padd< Packet1cd >() [1/2]

template<>

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

{ return Packet1cd(_mm_add_pd(a.v,b.v)); }

Referenced by predux< Packet2cf >().

Here is the caller graph for this function:

padd< Packet1cd >() [2/2]

template<>

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

{ return Packet1cd(a.v + b.v); }

padd< Packet2cd >()

template<>

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

{ return Packet2cd(_mm256_add_pd(a.v,b.v)); }

padd< Packet2cf >() [1/4]

template<>

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

{ return Packet2cf(a.v + b.v); }

Referenced by preduxp< Packet2cf >().

Here is the caller graph for this function:

padd< Packet2cf >() [2/4]

template<>

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

{ return Packet2cf(padd<Packet4f>(a.v,b.v)); }

References padd< Packet4f >().

Here is the call graph for this function:

padd< Packet2cf >() [3/4]

template<>

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

{ return Packet2cf(_mm_add_ps(a.v,b.v)); }

padd< Packet2cf >() [4/4]

template<>

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

{ return Packet2cf(padd<Packet4f>(a.v, b.v)); }

References padd< Packet4f >().

Here is the call graph for this function:

padd< Packet2d >() [1/2]

template<>

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

{ return _mm_add_pd(a,b); }

Referenced by plset< Packet2d >(), predux< Packet2d >(), predux< Packet4f >(), and preduxp< Packet2d >().

Here is the caller graph for this function:

padd< Packet2d >() [2/2]

template<>

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

{ return (a + b); }

padd< Packet4cf >()

template<>

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

{ return Packet4cf(_mm256_add_ps(a.v,b.v)); }

padd< Packet4d >()

template<>

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

{ return _mm256_add_pd(a,b); }

padd< Packet4f >() [1/4]

template<>

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

{ return a + b; }

Referenced by padd< Packet2cf >(), pdiv< Packet2cf >(), plset< Packet4f >(), pmul< Packet2cf >(), predux< Packet2cf >(), and preduxp< Packet2cf >().

Here is the caller graph for this function:

padd< Packet4f >() [2/4]

template<>

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

{ return vaddq_f32(a,b); }

padd< Packet4f >() [3/4]

template<>

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

{ return _mm_add_ps(a,b); }

padd< Packet4f >() [4/4]

template<>

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

{
  Packet4f c;
  c.v4f[0] = a.v4f[0] + b.v4f[0];
  c.v4f[1] = a.v4f[1] + b.v4f[1];
  return c;
}

padd< Packet4i >() [1/4]

template<>

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

{ return a + b; }

Referenced by plset< Packet4i >(), pmadd(), predux< Packet4i >(), and preduxp< Packet4i >().

Here is the caller graph for this function:

padd< Packet4i >() [2/4]

template<>

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

{ return vaddq_s32(a,b); }

padd< Packet4i >() [3/4]

template<>

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

{ return _mm_add_epi32(a,b); }

padd< Packet4i >() [4/4]

template<>

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

{ return (a + b); }

padd< Packet8d >()

template<>

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

                                                               {
  return _mm512_add_pd(a, b);
}

padd< Packet8f >()

template<>

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

{ return _mm256_add_ps(a,b); }

palign()

template<int Offset, typename PacketType >

void Eigen::internal::palign ( PacketType &  first, const PacketType &  second  )

inline

{
  palign_impl<Offset,PacketType>::run(first,second);
}

References Eigen::internal::palign_impl< Offset, PacketType >::run().

Here is the call graph for this function:

pand()

template<typename Packet >

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

inline

{ return a & b; }

Referenced by pand< Packet4f >(), plog< Packet4f >(), por< Packet4f >(), and pxor< Packet4f >().

Here is the caller graph for this function:

pand< Packet16f >()

template<>

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

                                                                  {
#ifdef EIGEN_VECTORIZE_AVX512DQ
  return _mm512_and_ps(a, b);
#else
  Packet16f res = _mm512_undefined_ps();
  Packet4f lane0_a = _mm512_extractf32x4_ps(a, 0);
  Packet4f lane0_b = _mm512_extractf32x4_ps(b, 0);
  res = _mm512_insertf32x4(res, _mm_and_ps(lane0_a, lane0_b), 0);
 
  Packet4f lane1_a = _mm512_extractf32x4_ps(a, 1);
  Packet4f lane1_b = _mm512_extractf32x4_ps(b, 1);
  res = _mm512_insertf32x4(res, _mm_and_ps(lane1_a, lane1_b), 1);
 
  Packet4f lane2_a = _mm512_extractf32x4_ps(a, 2);
  Packet4f lane2_b = _mm512_extractf32x4_ps(b, 2);
  res = _mm512_insertf32x4(res, _mm_and_ps(lane2_a, lane2_b), 2);
 
  Packet4f lane3_a = _mm512_extractf32x4_ps(a, 3);
  Packet4f lane3_b = _mm512_extractf32x4_ps(b, 3);
  res = _mm512_insertf32x4(res, _mm_and_ps(lane3_a, lane3_b), 3);
 
  return res;
#endif
}

pand< Packet1cd >() [1/2]

template<>

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

{ return Packet1cd(_mm_and_pd(a.v,b.v)); }

pand< Packet1cd >() [2/2]

template<>

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

{ return Packet1cd(vec_and(a.v,b.v)); }

pand< Packet2cd >()

template<>

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

{ return Packet2cd(_mm256_and_pd(a.v,b.v)); }

pand< Packet2cf >() [1/4]

template<>

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

{ return Packet2cf(pand<Packet4f>(a.v, b.v)); }

References pand< Packet4f >().

Here is the call graph for this function:

pand< Packet2cf >() [2/4]

template<>

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

{
  return Packet2cf(vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(a.v),vreinterpretq_u32_f32(b.v))));
}

pand< Packet2cf >() [3/4]

template<>

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

{ return Packet2cf(_mm_and_ps(a.v,b.v)); }

pand< Packet2cf >() [4/4]

template<>

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

{ return Packet2cf(pand<Packet4f>(a.v,b.v)); }

References pand< Packet4f >().

Here is the call graph for this function:

pand< Packet2d >() [1/2]

template<>

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

{ return _mm_and_pd(a,b); }

pand< Packet2d >() [2/2]

template<>

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

{ return vec_and(a, b); }

pand< Packet4cf >()

template<>

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

{ return Packet4cf(_mm256_and_ps(a.v,b.v)); }

pand< Packet4d >()

template<>

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

{ return _mm256_and_pd(a,b); }

pand< Packet4f >() [1/4]

template<>

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

{ return vec_and(a, b); }

Referenced by pand< Packet2cf >().

Here is the caller graph for this function:

pand< Packet4f >() [2/4]

template<>

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

{
  return vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b)));
}

pand< Packet4f >() [3/4]

template<>

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

{ return _mm_and_ps(a,b); }

pand< Packet4f >() [4/4]

template<>

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

{
  Packet4f res;
  res.v4f[0] = pand(a.v4f[0], b.v4f[0]);
  res.v4f[1] = pand(a.v4f[1], b.v4f[1]);
  return res;
}

References pand(), and Eigen::internal::Packet4f::v4f.

Here is the call graph for this function:

pand< Packet4i >() [1/4]

template<>

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

{ return vec_and(a, b); }

Referenced by pandnot< Packet4i >().

Here is the caller graph for this function:

pand< Packet4i >() [2/4]

template<>

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

{ return vandq_s32(a,b); }

pand< Packet4i >() [3/4]

template<>

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

{ return _mm_and_si128(a,b); }

pand< Packet4i >() [4/4]

template<>

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

{ return vec_and(a, b); }

pand< Packet8d >()

template<>

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

                                                               {
#ifdef EIGEN_VECTORIZE_AVX512DQ
  return _mm512_and_pd(a, b);
#else
  Packet8d res = _mm512_undefined_pd();
  Packet4d lane0_a = _mm512_extractf64x4_pd(a, 0);
  Packet4d lane0_b = _mm512_extractf64x4_pd(b, 0);
  res = _mm512_insertf64x4(res, _mm256_and_pd(lane0_a, lane0_b), 0);
 
  Packet4d lane1_a = _mm512_extractf64x4_pd(a, 1);
  Packet4d lane1_b = _mm512_extractf64x4_pd(b, 1);
  res = _mm512_insertf64x4(res, _mm256_and_pd(lane1_a, lane1_b), 1);
 
  return res;
#endif
}

pand< Packet8f >()

template<>

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

{ return _mm256_and_ps(a,b); }

pandnot()

template<typename Packet >

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

inline

{ return a & (!b); }

Referenced by pandnot< Packet4f >().

Here is the caller graph for this function:

pandnot< Packet16f >()

template<>

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

                                                                     {
#ifdef EIGEN_VECTORIZE_AVX512DQ
  return _mm512_andnot_ps(a, b);
#else
  Packet16f res = _mm512_undefined_ps();
  Packet4f lane0_a = _mm512_extractf32x4_ps(a, 0);
  Packet4f lane0_b = _mm512_extractf32x4_ps(b, 0);
  res = _mm512_insertf32x4(res, _mm_andnot_ps(lane0_a, lane0_b), 0);
 
  Packet4f lane1_a = _mm512_extractf32x4_ps(a, 1);
  Packet4f lane1_b = _mm512_extractf32x4_ps(b, 1);
  res = _mm512_insertf32x4(res, _mm_andnot_ps(lane1_a, lane1_b), 1);
 
  Packet4f lane2_a = _mm512_extractf32x4_ps(a, 2);
  Packet4f lane2_b = _mm512_extractf32x4_ps(b, 2);
  res = _mm512_insertf32x4(res, _mm_andnot_ps(lane2_a, lane2_b), 2);
 
  Packet4f lane3_a = _mm512_extractf32x4_ps(a, 3);
  Packet4f lane3_b = _mm512_extractf32x4_ps(b, 3);
  res = _mm512_insertf32x4(res, _mm_andnot_ps(lane3_a, lane3_b), 3);
 
  return res;
#endif
}

pandnot< Packet1cd >() [1/2]

template<>

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

{ return Packet1cd(_mm_andnot_pd(a.v,b.v)); }

pandnot< Packet1cd >() [2/2]

template<>

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

{ return Packet1cd(vec_and(a.v, vec_nor(b.v,b.v))); }

pandnot< Packet2cd >()

template<>

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

{ return Packet2cd(_mm256_andnot_pd(a.v,b.v)); }

pandnot< Packet2cf >() [1/4]

template<>

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

{ return Packet2cf(pandnot<Packet4f>(a.v, b.v)); }

References pandnot< Packet4f >().

Here is the call graph for this function:

pandnot< Packet2cf >() [2/4]

template<>

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

{
  return Packet2cf(vreinterpretq_f32_u32(vbicq_u32(vreinterpretq_u32_f32(a.v),vreinterpretq_u32_f32(b.v))));
}

pandnot< Packet2cf >() [3/4]

template<>

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

{ return Packet2cf(_mm_andnot_ps(a.v,b.v)); }

pandnot< Packet2cf >() [4/4]

template<>

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

{ return Packet2cf(pandnot<Packet4f>(a.v,b.v)); }

References pandnot< Packet4f >().

Here is the call graph for this function:

pandnot< Packet2d >() [1/2]

template<>

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

{ return _mm_andnot_pd(a,b); }

pandnot< Packet2d >() [2/2]

template<>

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

{ return vec_and(a, vec_nor(b, b)); }

pandnot< Packet4cf >()

template<>

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

{ return Packet4cf(_mm256_andnot_ps(a.v,b.v)); }

pandnot< Packet4d >()

template<>

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

{ return _mm256_andnot_pd(a,b); }

pandnot< Packet4f >() [1/4]

template<>

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

{ return vec_and(a, vec_nor(b, b)); }

Referenced by pandnot< Packet2cf >().

Here is the caller graph for this function:

pandnot< Packet4f >() [2/4]

template<>

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

{
  return vreinterpretq_f32_u32(vbicq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b)));
}

pandnot< Packet4f >() [3/4]

template<>

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

{ return _mm_andnot_ps(a,b); }

pandnot< Packet4f >() [4/4]

template<>

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

{
  Packet4f res;
  res.v4f[0] = pandnot(a.v4f[0], b.v4f[0]);
  res.v4f[1] = pandnot(a.v4f[1], b.v4f[1]);
  return res;
}

References pandnot(), and Eigen::internal::Packet4f::v4f.

Here is the call graph for this function:

pandnot< Packet4i >() [1/4]

template<>

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

{ return vec_and(a, vec_nor(b, b)); }

pandnot< Packet4i >() [2/4]

template<>

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

{ return vbicq_s32(a,b); }

pandnot< Packet4i >() [3/4]

template<>

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

{ return _mm_andnot_si128(a,b); }

pandnot< Packet4i >() [4/4]

template<>

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

{ return pand<Packet4i>(a, vec_nor(b, b)); }

References pand< Packet4i >().

Here is the call graph for this function:

pandnot< Packet8d >()

template<>

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

                                                                  {
#ifdef EIGEN_VECTORIZE_AVX512DQ
  return _mm512_andnot_pd(a, b);
#else
  Packet8d res = _mm512_undefined_pd();
  Packet4d lane0_a = _mm512_extractf64x4_pd(a, 0);
  Packet4d lane0_b = _mm512_extractf64x4_pd(b, 0);
  res = _mm512_insertf64x4(res, _mm256_andnot_pd(lane0_a, lane0_b), 0);
 
  Packet4d lane1_a = _mm512_extractf64x4_pd(a, 1);
  Packet4d lane1_b = _mm512_extractf64x4_pd(b, 1);
  res = _mm512_insertf64x4(res, _mm256_andnot_pd(lane1_a, lane1_b), 1);
 
  return res;
#endif
}

pandnot< Packet8f >()

template<>

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

{ return _mm256_andnot_ps(a,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
	)

{
  // TODO when EIGEN_USE_BLAS is defined,
  // we should still enable OMP for other scalar types
#if !(defined (EIGEN_HAS_OPENMP)) || defined (EIGEN_USE_BLAS)
  // FIXME the transpose variable is only needed to properly split
  // the matrix product when multithreading is enabled. This is a temporary
  // fix to support row-major destination matrices. This whole
  // parallelizer mechanism has to be redisigned anyway.
  EIGEN_UNUSED_VARIABLE(depth);
  EIGEN_UNUSED_VARIABLE(transpose);
  func(0,rows, 0,cols);
#else
 
  // Dynamically check whether we should enable or disable OpenMP.
  // The conditions are:
  // - the max number of threads we can create is greater than 1
  // - we are not already in a parallel code
  // - the sizes are large enough
 
  // compute the maximal number of threads from the size of the product:
  // This first heuristic takes into account that the product kernel is fully optimized when working with nr columns at once.
  Index size = transpose ? rows : cols;
  Index pb_max_threads = std::max<Index>(1,size / Functor::Traits::nr);
 
  // compute the maximal number of threads from the total amount of work:
  double work = static_cast<double>(rows) * static_cast<double>(cols) *
      static_cast<double>(depth);
  double kMinTaskSize = 50000;  // FIXME improve this heuristic.
  pb_max_threads = std::max<Index>(1, std::min<Index>(pb_max_threads, work / kMinTaskSize));
 
  // compute the number of threads we are going to use
  Index threads = std::min<Index>(nbThreads(), pb_max_threads);
 
  // if multi-threading is explicitely disabled, not useful, or if we already are in a parallel session,
  // then abort multi-threading
  // FIXME omp_get_num_threads()>1 only works for openmp, what if the user does not use openmp?
  if((!Condition) || (threads==1) || (omp_get_num_threads()>1))
    return func(0,rows, 0,cols);
 
  Eigen::initParallel();
  func.initParallelSession(threads);
 
  if(transpose)
    std::swap(rows,cols);
 
  ei_declare_aligned_stack_constructed_variable(GemmParallelInfo<Index>,info,threads,0);
 
  #pragma omp parallel num_threads(threads)
  {
    Index i = omp_get_thread_num();
    // Note that the actual number of threads might be lower than the number of request ones.
    Index actual_threads = omp_get_num_threads();
 
    Index blockCols = (cols / actual_threads) & ~Index(0x3);
    Index blockRows = (rows / actual_threads);
    blockRows = (blockRows/Functor::Traits::mr)*Functor::Traits::mr;
 
    Index r0 = i*blockRows;
    Index actualBlockRows = (i+1==actual_threads) ? rows-r0 : blockRows;
 
    Index c0 = i*blockCols;
    Index actualBlockCols = (i+1==actual_threads) ? cols-c0 : blockCols;
 
    info[i].lhs_start = r0;
    info[i].lhs_length = actualBlockRows;
 
    if(transpose) func(c0, actualBlockCols, 0, rows, info);
    else          func(0, rows, c0, actualBlockCols, info);
  }
#endif
}

References ei_declare_aligned_stack_constructed_variable, EIGEN_UNUSED_VARIABLE, Eigen::initParallel(), and Eigen::nbThreads().

Referenced by Eigen::internal::generic_product_impl< Lhs, Rhs, DenseShape, DenseShape, GemmProduct >::scaleAndAddTo().

Here is the call graph for this function:

Here is the caller graph for this function:

parg()

template<typename Packet >

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

inline

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

References arg().

Referenced by Eigen::internal::scalar_arg_op< Scalar >::packetOp().

Here is the call graph for this function:

Here is the caller graph for this function:

partial_lu_inplace()

template<typename MatrixType , typename TranspositionType >

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

{
  eigen_assert(lu.cols() == row_transpositions.size());
  eigen_assert((&row_transpositions.coeffRef(1)-&row_transpositions.coeffRef(0)) == 1);
 
  partial_lu_impl
    <typename MatrixType::Scalar, MatrixType::Flags&RowMajorBit?RowMajor:ColMajor, typename TranspositionType::StorageIndex>
    ::blocked_lu(lu.rows(), lu.cols(), &lu.coeffRef(0,0), lu.outerStride(), &row_transpositions.coeffRef(0), nb_transpositions);
}

References Eigen::ColMajor, eigen_assert, Eigen::RowMajor, and Eigen::RowMajorBit.

Referenced by Eigen::PartialPivLU< _MatrixType >::compute().

Here is the caller graph for this function:

pasin()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pasin

(

const Packet &

a

)

{ using std::asin; return asin(a); }

References asin().

Here is the call graph for this function:

patan()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::patan

(

const Packet &

a

)

{ using std::atan; return atan(a); }

References atan().

Here is the call graph for this function:

pblend() [1/15]

template<>

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

                                                         {
  assert(false && "To be implemented");
  return Packet16f();
}

pblend() [2/15]

template<>

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

                                                                                                                                        {
  __m128d result = pblend<Packet2d>(ifPacket, _mm_castps_pd(thenPacket.v), _mm_castps_pd(elsePacket.v));
  return Packet2cf(_mm_castpd_ps(result));
}

pblend() [3/15]

template<>

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

                                                                                                                                       {
  Packet2cf result;
  const Selector<4> ifPacket4 = { ifPacket.select[0], ifPacket.select[0], ifPacket.select[1], ifPacket.select[1] };
  result.v = pblend<Packet4f>(ifPacket4, thenPacket.v, elsePacket.v);
  return result;
}

References Eigen::internal::Selector< N >::select, and Eigen::internal::Packet2cf::v.

pblend() [4/15]

template<>

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

                                                                                                                                    {
  const __m128d zero = _mm_setzero_pd();
  const __m128d select = _mm_set_pd(ifPacket.select[1], ifPacket.select[0]);
  __m128d false_mask = _mm_cmpeq_pd(select, zero);
#ifdef EIGEN_VECTORIZE_SSE4_1
  return _mm_blendv_pd(thenPacket, elsePacket, false_mask);
#else
  return _mm_or_pd(_mm_andnot_pd(false_mask, thenPacket), _mm_and_pd(false_mask, elsePacket));
#endif
}

References Eigen::internal::Selector< N >::select.

pblend() [5/15]

template<>

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

                                                                                                                                    {
  Packet2ul select = { ifPacket.select[0], ifPacket.select[1] };
  Packet2ul mask = vec_cmpeq(select, reinterpret_cast<Packet2ul>(p2l_ONE));
  return vec_sel(elsePacket, thenPacket, mask);
}

References Eigen::internal::Selector< N >::select.

pblend() [6/15]

template<>

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

                                                                                                                                    {
  const __m256d zero = _mm256_setzero_pd();
  const __m256d select = _mm256_set_pd(ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
  __m256d false_mask = _mm256_cmp_pd(select, zero, _CMP_EQ_UQ);
  return _mm256_blendv_pd(thenPacket, elsePacket, false_mask);
}

References Eigen::internal::Selector< N >::select.

pblend() [7/15]

template<>

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

                                                                                                                                    {
  Packet4ui select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3] };
  Packet4ui mask = reinterpret_cast<Packet4ui>(vec_cmpeq(reinterpret_cast<Packet4ui>(select), reinterpret_cast<Packet4ui>(p4i_ONE)));
  return vec_sel(elsePacket, thenPacket, mask);
}

References Eigen::internal::Selector< N >::select.

pblend() [8/15]

template<>

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

                                                                                                                                    {
  const __m128 zero = _mm_setzero_ps();
  const __m128 select = _mm_set_ps(ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
  __m128 false_mask = _mm_cmpeq_ps(select, zero);
#ifdef EIGEN_VECTORIZE_SSE4_1
  return _mm_blendv_ps(thenPacket, elsePacket, false_mask);
#else
  return _mm_or_ps(_mm_andnot_ps(false_mask, thenPacket), _mm_and_ps(false_mask, elsePacket));
#endif
}

References Eigen::internal::Selector< N >::select.

pblend() [9/15]

template<>

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

                                                                                                                                    {
  Packet2ul select_hi = { ifPacket.select[0], ifPacket.select[1] };
  Packet2ul select_lo = { ifPacket.select[2], ifPacket.select[3] };
  Packet2ul mask_hi = vec_cmpeq(select_hi, reinterpret_cast<Packet2ul>(p2l_ONE));
  Packet2ul mask_lo = vec_cmpeq(select_lo, reinterpret_cast<Packet2ul>(p2l_ONE));
  Packet4f result;
  result.v4f[0] = vec_sel(elsePacket.v4f[0], thenPacket.v4f[0], mask_hi);
  result.v4f[1] = vec_sel(elsePacket.v4f[1], thenPacket.v4f[1], mask_lo);
  return result;
}

References Eigen::internal::Selector< N >::select, and Eigen::internal::Packet4f::v4f.

pblend() [10/15]

template<>

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

                                                                                                                                    {
  Packet4ui select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3] };
  Packet4ui mask = reinterpret_cast<Packet4ui>(vec_cmpeq(reinterpret_cast<Packet4ui>(select), reinterpret_cast<Packet4ui>(p4i_ONE)));
  return vec_sel(elsePacket, thenPacket, mask);
}

References Eigen::internal::Selector< N >::select.

Referenced by pinsertfirst(), and pinsertlast().

Here is the caller graph for this function:

pblend() [11/15]

template<>

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

                                                                                                                                    {
  const __m128i zero = _mm_setzero_si128();
  const __m128i select = _mm_set_epi32(ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
  __m128i false_mask = _mm_cmpeq_epi32(select, zero);
#ifdef EIGEN_VECTORIZE_SSE4_1
  return _mm_blendv_epi8(thenPacket, elsePacket, false_mask);
#else
  return _mm_or_si128(_mm_andnot_si128(false_mask, thenPacket), _mm_and_si128(false_mask, elsePacket));
#endif
}

References Eigen::internal::Selector< N >::select.

pblend() [12/15]

template<>

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

                                                                                                                                    {
  Packet4ui select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3] };
  Packet4ui mask = vec_cmpeq(select, reinterpret_cast<Packet4ui>(p4i_ONE));
  return vec_sel(elsePacket, thenPacket, mask);
}

References Eigen::internal::Selector< N >::select.

pblend() [13/15]

template<>

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

                                                       {
  assert(false && "To be implemented");
  return Packet8d();
}

pblend() [14/15]

template<>

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

                                                                                                                                    {
  const __m256 zero = _mm256_setzero_ps();
  const __m256 select = _mm256_set_ps(ifPacket.select[7], ifPacket.select[6], ifPacket.select[5], ifPacket.select[4], ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
  __m256 false_mask = _mm256_cmp_ps(select, zero, _CMP_EQ_UQ);
  return _mm256_blendv_ps(thenPacket, elsePacket, false_mask);
}

References Eigen::internal::Selector< N >::select.

pblend() [15/15]

template<typename Packet >

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

inline

                                                                                                                  {
  return ifPacket.select[0] ? thenPacket : elsePacket;
}

pbroadcast2()

template<typename Packet >

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

inline

{
  a0 = pload1<Packet>(a+0);
  a1 = pload1<Packet>(a+1);
}

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

{
  a0 = pload1<Packet>(a+0);
  a1 = pload1<Packet>(a+1);
  a2 = pload1<Packet>(a+2);
  a3 = pload1<Packet>(a+3);
}

Referenced by Eigen::internal::gebp_traits< _LhsScalar, _RhsScalar, _ConjLhs, _ConjRhs >::broadcastRhs(), Eigen::internal::gebp_traits< std::complex< RealScalar >, RealScalar, _ConjLhs, false >::broadcastRhs(), and Eigen::internal::gebp_traits< RealScalar, std::complex< RealScalar >, false, _ConjRhs >::broadcastRhs().

Here is the caller graph for this function:

pbroadcast4< Packet2d >() [1/2]

template<>

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

{
#ifdef EIGEN_VECTORIZE_SSE3
  a0 = _mm_loaddup_pd(a+0);
  a1 = _mm_loaddup_pd(a+1);
  a2 = _mm_loaddup_pd(a+2);
  a3 = _mm_loaddup_pd(a+3);
#else
  a1 = pload<Packet2d>(a);
  a0 = vec2d_swizzle1(a1, 0,0);
  a1 = vec2d_swizzle1(a1, 1,1);
  a3 = pload<Packet2d>(a+2);
  a2 = vec2d_swizzle1(a3, 0,0);
  a3 = vec2d_swizzle1(a3, 1,1);
#endif
}

References pload< Packet2d >(), and vec2d_swizzle1.

Here is the call graph for this function:

pbroadcast4< Packet2d >() [2/2]

template<>

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

{
  a1 = pload<Packet2d>(a);
  a0 = vec_splat(a1, 0);
  a1 = vec_splat(a1, 1);
  a3 = pload<Packet2d>(a+2);
  a2 = vec_splat(a3, 0);
  a3 = vec_splat(a3, 1);
}

References pload< Packet2d >().

Here is the call graph for this function:

pbroadcast4< Packet4f >() [1/3]

template<>

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

{
  a3 = pload<Packet4f>(a);
  a0 = vec_splat(a3, 0);
  a1 = vec_splat(a3, 1);
  a2 = vec_splat(a3, 2);
  a3 = vec_splat(a3, 3);
}

References pload< Packet4f >().

Here is the call graph for this function:

pbroadcast4< Packet4f >() [2/3]

template<>

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

{
  a3 = pload<Packet4f>(a);
  a0 = vec4f_swizzle1(a3, 0,0,0,0);
  a1 = vec4f_swizzle1(a3, 1,1,1,1);
  a2 = vec4f_swizzle1(a3, 2,2,2,2);
  a3 = vec4f_swizzle1(a3, 3,3,3,3);
}

References pload< Packet4f >(), and vec4f_swizzle1.

Here is the call graph for this function:

pbroadcast4< Packet4f >() [3/3]

template<>

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

{
  a3 = pload<Packet4f>(a);
  a0 = vec_splat_packet4f<0>(a3);
  a1 = vec_splat_packet4f<1>(a3);
  a2 = vec_splat_packet4f<2>(a3);
  a3 = vec_splat_packet4f<3>(a3);
}

References pload< Packet4f >().

Here is the call graph for this function:

pbroadcast4< Packet4i >() [1/2]

template<>

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

{
  a3 = pload<Packet4i>(a);
  a0 = vec_splat(a3, 0);
  a1 = vec_splat(a3, 1);
  a2 = vec_splat(a3, 2);
  a3 = vec_splat(a3, 3);
}

References pload< Packet4i >().

Here is the call graph for this function:

pbroadcast4< Packet4i >() [2/2]

template<>

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

{
  a3 = pload<Packet4i>(a);
  a0 = vec_splat(a3, 0);
  a1 = vec_splat(a3, 1);
  a2 = vec_splat(a3, 2);
  a3 = vec_splat(a3, 3);
}

References pload< Packet4i >().

Here is the call graph for this function:

pcast() [1/3]

template<typename SrcPacket , typename TgtPacket >

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

inline

                          {
  return static_cast<TgtPacket>(a);
}

pcast() [2/3]

template<typename SrcPacket , typename TgtPacket >

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

inline

                                              {
  return static_cast<TgtPacket>(a);
}

pcast() [3/3]

template<typename SrcPacket , typename TgtPacket >

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

inline

                                                                                      {
  return static_cast<TgtPacket>(a);
}

pcast< Packet2d, Packet4f >()

template<>

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

                                                                                                        {
  return _mm_shuffle_ps(_mm_cvtpd_ps(a), _mm_cvtpd_ps(b), (1 << 2) | (1 << 6));
}

pcast< Packet4f, Packet2d >()

template<>

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

(

const Packet4f &

a

)

                                                                                     {
  // Simply discard the second half of the input
  return _mm_cvtps_pd(a);
}

pcast< Packet4f, Packet4i >()

template<>

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

(

const Packet4f &

a

)

                                                                                     {
  return _mm_cvttps_epi32(a);
}

pcast< Packet4i, Packet4f >()

template<>

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

(

const Packet4i &

a

)

                                                                                     {
  return _mm_cvtepi32_ps(a);
}

pcast< Packet8f, Packet8i >()

template<>

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

(

const Packet8f &

a

)

                                                                                     {
  return _mm256_cvtps_epi32(a);
}

pcast< Packet8i, Packet8f >()

template<>

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

(

const Packet8i &

a

)

                                                                                     {
  return _mm256_cvtepi32_ps(a);
}

pceil()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pceil

(

const Packet &

a

)

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

References ceil(), and Eigen::numext::ceil().

Here is the call graph for this function:

pceil< Packet2d >()

template<>

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

(

const Packet2d &

a

)

{ return vec_ceil(a); }

pceil< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pceil< Packet4d >

(

const Packet4d &

a

)

{ return _mm256_ceil_pd(a); }

pceil< Packet4f >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pceil< Packet4f >

(

const Packet4f &

a

)

{ return vec_ceil(a); }

pceil< Packet4f >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pceil< Packet4f >

(

const Packet4f &

a

)

{
  Packet4f res;
  res.v4f[0] = vec_ceil(a.v4f[0]);
  res.v4f[1] = vec_ceil(a.v4f[1]);
  return res;
}

References Eigen::internal::Packet4f::v4f.

pceil< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pceil< Packet8f >

(

const Packet8f &

a

)

{ return _mm256_ceil_ps(a); }

pconj() [1/25]

template<typename Packet >

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

inline

{ return numext::conj(a); }

pconj() [2/25]

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pconj

(

const Packet16f &

a

)

                                                        {
  return a;
}

pconj() [3/25]

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::pconj

(

const Packet16i &

a

)

                                                        {
  return a;
}

pconj() [4/25]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pconj

(

const Packet1cd &

a

)

{
  const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x80000000,0x0,0x0,0x0));
  return Packet1cd(_mm_xor_pd(a.v,mask));
}

pconj() [5/25]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pconj

(

const Packet1cd &

a

)

{ return Packet1cd((Packet2d)vec_xor((Packet2d)a.v, (Packet2d)p2ul_CONJ_XOR2)); }

References p2ul_CONJ_XOR2.

pconj() [6/25]

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pconj

(

const Packet2cd &

a

)

{
  const __m256d mask = _mm256_castsi256_pd(_mm256_set_epi32(0x80000000,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0));
  return Packet2cd(_mm256_xor_pd(a.v,mask));
}

pconj() [7/25]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pconj

(

const Packet2cf &

a

)

{ return Packet2cf(pxor<Packet4f>(a.v, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR))); }

References p4ui_CONJ_XOR, and pxor< Packet4f >().

Referenced by Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs >::acc(), Eigen::internal::scalar_conjugate_op< Scalar >::packetOp(), pconj(), Eigen::internal::conj_if< true >::pconj(), pdiv< Packet2cd >(), pdiv< Packet4cf >(), Eigen::internal::conj_helper< Packet1cd, Packet1cd, false, true >::pmul(), Eigen::internal::conj_helper< Packet1cd, Packet1cd, true, false >::pmul(), Eigen::internal::conj_helper< Packet1cd, Packet1cd, true, true >::pmul(), Eigen::internal::conj_helper< Packet2cd, Packet2cd, false, true >::pmul(), Eigen::internal::conj_helper< Packet2cd, Packet2cd, true, false >::pmul(), Eigen::internal::conj_helper< Packet2cd, Packet2cd, true, true >::pmul(), Eigen::internal::conj_helper< Packet2cf, Packet2cf, false, true >::pmul(), Eigen::internal::conj_helper< Packet2cf, Packet2cf, true, false >::pmul(), Eigen::internal::conj_helper< Packet2cf, Packet2cf, true, true >::pmul(), Eigen::internal::conj_helper< Packet4cf, Packet4cf, false, true >::pmul(), Eigen::internal::conj_helper< Packet4cf, Packet4cf, true, false >::pmul(), and Eigen::internal::conj_helper< Packet4cf, Packet4cf, true, true >::pmul().

Here is the call graph for this function:

Here is the caller graph for this function:

pconj() [8/25]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pconj

(

const Packet2cf &

a

)

{
  Packet4ui b = vreinterpretq_u32_f32(a.v);
  return Packet2cf(vreinterpretq_f32_u32(veorq_u32(b, p4ui_CONJ_XOR())));
}

References p4ui_CONJ_XOR.

pconj() [9/25]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pconj

(

const Packet2cf &

a

)

{
  const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x00000000,0x80000000,0x00000000,0x80000000));
  return Packet2cf(_mm_xor_ps(a.v,mask));
}

pconj() [10/25]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pconj

(

const Packet2cf &

a

)

{
  Packet2cf res;
  res.v.v4f[0] = pconj(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[0]))).v;
  res.v.v4f[1] = pconj(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[1]))).v;
  return res;
}

References pconj(), Eigen::internal::Packet2cf::v, and Eigen::internal::Packet4f::v4f.

Here is the call graph for this function:

pconj() [11/25]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pconj

(

const Packet2d &

a

)

{ return a; }

pconj() [12/25]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pconj

(

const Packet2d &

a

)

{ return a; }

pconj() [13/25]

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pconj

(

const Packet4cf &

a

)

{
  const __m256 mask = _mm256_castsi256_ps(_mm256_setr_epi32(0x00000000,0x80000000,0x00000000,0x80000000,0x00000000,0x80000000,0x00000000,0x80000000));
  return Packet4cf(_mm256_xor_ps(a.v,mask));
}

pconj() [14/25]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pconj

(

const Packet4d &

a

)

{ return a; }

pconj() [15/25]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pconj

(

const Packet4f &

a

)

{ return a; }

pconj() [16/25]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pconj

(

const Packet4f &

a

)

{ return a; }

pconj() [17/25]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pconj

(

const Packet4f &

a

)

{ return a; }

pconj() [18/25]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pconj

(

const Packet4f &

a

)

{ return a; }

pconj() [19/25]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pconj

(

const Packet4i &

a

)

{ return a; }

pconj() [20/25]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pconj

(

const Packet4i &

a

)

{ return a; }

pconj() [21/25]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pconj

(

const Packet4i &

a

)

{ return a; }

pconj() [22/25]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pconj

(

const Packet4i &

a

)

{ return a; }

pconj() [23/25]

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pconj

(

const Packet8d &

a

)

                                                      {
  return a;
}

pconj() [24/25]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pconj

(

const Packet8f &

a

)

{ return a; }

pconj() [25/25]

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::pconj

(

const Packet8i &

a

)

{ return a; }

pcos()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pcos

(

const Packet &

a

)

{ using std::cos; return cos(a); }

References cos().

Here is the call graph for this function:

pcos< Packet4f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::pcos< Packet4f >

(

const Packet4f &

_x

)

{
  Packet4f x = _x;
  _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f);
  _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
 
  _EIGEN_DECLARE_CONST_Packet4i(1, 1);
  _EIGEN_DECLARE_CONST_Packet4i(not1, ~1);
  _EIGEN_DECLARE_CONST_Packet4i(2, 2);
  _EIGEN_DECLARE_CONST_Packet4i(4, 4);
 
  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP1,-0.78515625f);
  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP2, -2.4187564849853515625e-4f);
  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP3, -3.77489497744594108e-8f);
  _EIGEN_DECLARE_CONST_Packet4f(sincof_p0, -1.9515295891E-4f);
  _EIGEN_DECLARE_CONST_Packet4f(sincof_p1,  8.3321608736E-3f);
  _EIGEN_DECLARE_CONST_Packet4f(sincof_p2, -1.6666654611E-1f);
  _EIGEN_DECLARE_CONST_Packet4f(coscof_p0,  2.443315711809948E-005f);
  _EIGEN_DECLARE_CONST_Packet4f(coscof_p1, -1.388731625493765E-003f);
  _EIGEN_DECLARE_CONST_Packet4f(coscof_p2,  4.166664568298827E-002f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_FOPI, 1.27323954473516f); // 4 / M_PI
 
  Packet4f xmm1, xmm2, xmm3, y;
  Packet4i emm0, emm2;
 
  x = pabs(x);
 
  /* scale by 4/Pi */
  y = pmul(x, p4f_cephes_FOPI);
 
  /* get the integer part of y */
  emm2 = _mm_cvttps_epi32(y);
  /* j=(j+1) & (~1) (see the cephes sources) */
  emm2 = _mm_add_epi32(emm2, p4i_1);
  emm2 = _mm_and_si128(emm2, p4i_not1);
  y = _mm_cvtepi32_ps(emm2);
 
  emm2 = _mm_sub_epi32(emm2, p4i_2);
 
  /* get the swap sign flag */
  emm0 = _mm_andnot_si128(emm2, p4i_4);
  emm0 = _mm_slli_epi32(emm0, 29);
  /* get the polynom selection mask */
  emm2 = _mm_and_si128(emm2, p4i_2);
  emm2 = _mm_cmpeq_epi32(emm2, _mm_setzero_si128());
 
  Packet4f sign_bit = _mm_castsi128_ps(emm0);
  Packet4f poly_mask = _mm_castsi128_ps(emm2);
 
  /* The magic pass: "Extended precision modular arithmetic"
     x = ((x - y * DP1) - y * DP2) - y * DP3; */
  xmm1 = pmul(y, p4f_minus_cephes_DP1);
  xmm2 = pmul(y, p4f_minus_cephes_DP2);
  xmm3 = pmul(y, p4f_minus_cephes_DP3);
  x = padd(x, xmm1);
  x = padd(x, xmm2);
  x = padd(x, xmm3);
 
  /* Evaluate the first polynom  (0 <= x <= Pi/4) */
  y = p4f_coscof_p0;
  Packet4f z = pmul(x,x);
 
  y = pmadd(y,z,p4f_coscof_p1);
  y = pmadd(y,z,p4f_coscof_p2);
  y = pmul(y, z);
  y = pmul(y, z);
  Packet4f tmp = _mm_mul_ps(z, p4f_half);
  y = psub(y, tmp);
  y = padd(y, p4f_1);
 
  /* Evaluate the second polynom  (Pi/4 <= x <= 0) */
  Packet4f y2 = p4f_sincof_p0;
  y2 = pmadd(y2, z, p4f_sincof_p1);
  y2 = pmadd(y2, z, p4f_sincof_p2);
  y2 = pmul(y2, z);
  y2 = pmadd(y2, x, x);
 
  /* select the correct result from the two polynoms */
  y2 = _mm_and_ps(poly_mask, y2);
  y  = _mm_andnot_ps(poly_mask, y);
  y  = _mm_or_ps(y,y2);
 
  /* update the sign */
  return _mm_xor_ps(y, sign_bit);
}

References _EIGEN_DECLARE_CONST_Packet4f, _EIGEN_DECLARE_CONST_Packet4i, pabs(), padd(), pmadd(), pmul(), psub(), and y.

Here is the call graph for this function:

pcosh()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pcosh

(

const Packet &

a

)

{ using std::cosh; return cosh(a); }

References cosh().

Here is the call graph for this function:

pcplxflip() [1/3]

template<typename Packet >

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

inline

{
  // FIXME: uncomment the following in case we drop the internal imag and real functions.
//   using std::imag;
//   using std::real;
  return Packet(imag(a),real(a));
}

References imag(), and real().

Here is the call graph for this function:

pcplxflip() [2/3]

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pcplxflip

(

const Packet1cd &

x

)

{
  return Packet1cd(preverse(Packet2d(x.v)));
}

References preverse().

Here is the call graph for this function:

pcplxflip() [3/3]

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pcplxflip

(

const Packet2cf &

x

)

{
  return Packet2cf(vec4f_swizzle1(x.v, 1, 0, 3, 2));
}

References vec4f_swizzle1.

Referenced by Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs >::acc().

Here is the caller graph for this function:

pcplxflip< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pcplxflip< Packet2cd >

(

const Packet2cd &

x

)

{
  return Packet2cd(_mm256_shuffle_pd(x.v, x.v, 0x5));
}

pcplxflip< Packet2cf >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pcplxflip< Packet2cf >

(

const Packet2cf &

a

)

{
  return Packet2cf(vrev64q_f32(a.v));
}

pcplxflip< Packet2cf >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pcplxflip< Packet2cf >

(

const Packet2cf &

x

)

{
  return Packet2cf(vec_perm(x.v, x.v, p16uc_COMPLEX32_REV));
}

References p16uc_COMPLEX32_REV.

pcplxflip< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pcplxflip< Packet4cf >

(

const Packet4cf &

x

)

{
  return Packet4cf(_mm256_shuffle_ps(x.v, x.v, _MM_SHUFFLE(2, 3, 0 ,1)));
}

pdiv()

template<typename Packet >

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

inline

                         { return a/b; }

Referenced by Eigen::internal::div_assign_op< DstScalar, SrcScalar >::assignPacket(), generic_fast_tanh_float(), Eigen::internal::scalar_quotient_op< LhsScalar, RhsScalar >::packetOp(), pdiv< Packet1cd >(), pdiv< Packet2cf >(), pexp< Packet2d >(), and prsqrt().

Here is the caller graph for this function:

pdiv< Packet16f >()

template<>

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

                                                                  {
  return _mm512_div_ps(a, b);
}

pdiv< Packet1cd >() [1/2]

template<>

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

{
  // TODO optimize it for SSE3 and 4
  Packet1cd res = conj_helper<Packet1cd,Packet1cd,false,true>().pmul(a,b);
  __m128d s = _mm_mul_pd(b.v,b.v);
  return Packet1cd(_mm_div_pd(res.v, _mm_add_pd(s,_mm_shuffle_pd(s, s, 0x1))));
}

References Eigen::internal::conj_helper< LhsScalar, RhsScalar, ConjLhs, ConjRhs >::pmul(), and Eigen::internal::Packet1cd::v.

Referenced by pdiv< Packet2cf >().

Here is the call graph for this function:

Here is the caller graph for this function:

pdiv< Packet1cd >() [2/2]

template<>

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

{
  // TODO optimize it for AltiVec
  Packet1cd res = conj_helper<Packet1cd,Packet1cd,false,true>().pmul(a,b);
  Packet2d s = vec_madd(b.v, b.v, p2d_ZERO_);
  return Packet1cd(pdiv(res.v, s + vec_perm(s, s, p16uc_REVERSE64)));
}

References p16uc_REVERSE64, p2d_ZERO_, pdiv(), Eigen::internal::conj_helper< LhsScalar, RhsScalar, ConjLhs, ConjRhs >::pmul(), and Eigen::internal::Packet1cd::v.

Here is the call graph for this function:

pdiv< Packet2cd >()

template<>

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

{
  Packet2cd num = pmul(a, pconj(b));
  __m256d tmp = _mm256_mul_pd(b.v, b.v);
  __m256d denom = _mm256_hadd_pd(tmp, tmp);
  return Packet2cd(_mm256_div_pd(num.v, denom));
}

References pconj(), pmul(), and Eigen::internal::Packet2cd::v.

Here is the call graph for this function:

pdiv< Packet2cf >() [1/4]

template<>

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

{
  // TODO optimize it for AltiVec
  Packet2cf res = conj_helper<Packet2cf,Packet2cf,false,true>().pmul(a, b);
  Packet4f s = pmul<Packet4f>(b.v, b.v);
  return Packet2cf(pdiv(res.v, padd<Packet4f>(s, vec_perm(s, s, p16uc_COMPLEX32_REV))));
}

References p16uc_COMPLEX32_REV, padd< Packet4f >(), pdiv(), Eigen::internal::conj_helper< LhsScalar, RhsScalar, ConjLhs, ConjRhs >::pmul(), pmul< Packet4f >(), and Eigen::internal::Packet2cf::v.

Here is the call graph for this function:

pdiv< Packet2cf >() [2/4]

template<>

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

{
  // TODO optimize it for NEON
  Packet2cf res = conj_helper<Packet2cf,Packet2cf,false,true>().pmul(a,b);
  Packet4f s, rev_s;
 
  // this computes the norm
  s = vmulq_f32(b.v, b.v);
  rev_s = vrev64q_f32(s);
 
  return Packet2cf(pdiv<Packet4f>(res.v, vaddq_f32(s,rev_s)));
}

References pdiv< Packet4f >(), and Eigen::internal::conj_helper< LhsScalar, RhsScalar, ConjLhs, ConjRhs >::pmul().

Here is the call graph for this function:

pdiv< Packet2cf >() [3/4]

template<>

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

{
  // TODO optimize it for SSE3 and 4
  Packet2cf res = conj_helper<Packet2cf,Packet2cf,false,true>().pmul(a,b);
  __m128 s = _mm_mul_ps(b.v,b.v);
  return Packet2cf(_mm_div_ps(res.v,_mm_add_ps(s,_mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(s), 0xb1)))));
}

References Eigen::internal::conj_helper< LhsScalar, RhsScalar, ConjLhs, ConjRhs >::pmul().

Here is the call graph for this function:

pdiv< Packet2cf >() [4/4]

template<>

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

{
  // TODO optimize it for AltiVec
  Packet2cf res;
  res.cd[0] = pdiv<Packet1cd>(a.cd[0], b.cd[0]);
  res.cd[1] = pdiv<Packet1cd>(a.cd[1], b.cd[1]);
  return res;
}

References pdiv< Packet1cd >().

Here is the call graph for this function:

pdiv< Packet2d >() [1/2]

template<>

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

{ return _mm_div_pd(a,b); }

pdiv< Packet2d >() [2/2]

template<>

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

{ return (a / b); }

pdiv< Packet4cf >()

template<>

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

{
  Packet4cf num = pmul(a, pconj(b));
  __m256 tmp = _mm256_mul_ps(b.v, b.v);
  __m256 tmp2    = _mm256_shuffle_ps(tmp,tmp,0xB1);
  __m256 denom = _mm256_add_ps(tmp, tmp2);
  return Packet4cf(_mm256_div_ps(num.v, denom));
}

References pconj(), pmul(), and Eigen::internal::Packet4cf::v.

Here is the call graph for this function:

pdiv< Packet4d >()

template<>

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

{ return _mm256_div_pd(a,b); }

pdiv< Packet4f >() [1/4]

template<>

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

{
#ifndef __VSX__  // VSX actually provides a div instruction
  Packet4f t, y_0, y_1;
 
  // Altivec does not offer a divide instruction, we have to do a reciprocal approximation
  y_0 = vec_re(b);
 
  // Do one Newton-Raphson iteration to get the needed accuracy
  t   = vec_nmsub(y_0, b, p4f_ONE);
  y_1 = vec_madd(y_0, t, y_0);
 
  return vec_madd(a, y_1, p4f_MZERO);
#else
  return vec_div(a, b);
#endif
}

References p4f_MZERO, and p4f_ONE.

Referenced by pdiv< Packet2cf >().

Here is the caller graph for this function:

pdiv< Packet4f >() [2/4]

template<>

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

{
#if EIGEN_ARCH_ARM64
  return vdivq_f32(a,b);
#else
  Packet4f inv, restep, div;
 
  // NEON does not offer a divide instruction, we have to do a reciprocal approximation
  // However NEON in contrast to other SIMD engines (AltiVec/SSE), offers
  // a reciprocal estimate AND a reciprocal step -which saves a few instructions
  // vrecpeq_f32() returns an estimate to 1/b, which we will finetune with
  // Newton-Raphson and vrecpsq_f32()
  inv = vrecpeq_f32(b);
 
  // This returns a differential, by which we will have to multiply inv to get a better
  // approximation of 1/b.
  restep = vrecpsq_f32(b, inv);
  inv = vmulq_f32(restep, inv);
 
  // Finally, multiply a by 1/b and get the wanted result of the division.
  div = vmulq_f32(a, inv);
 
  return div;
#endif
}

pdiv< Packet4f >() [3/4]

template<>

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

{ return _mm_div_ps(a,b); }

pdiv< Packet4f >() [4/4]

template<>

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

{
  Packet4f c;
  c.v4f[0] = a.v4f[0] / b.v4f[0];
  c.v4f[1] = a.v4f[1] / b.v4f[1];
  return c;
}

pdiv< Packet4i >() [1/3]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pdiv< Packet4i >	(	const Packet4i &	,
		const Packet4i &
	)

{ eigen_assert(false && "packet integer division are not supported by AltiVec");
  return pset1<Packet4i>(0);
}

References eigen_assert, and pset1< Packet4i >().

Here is the call graph for this function:

pdiv< Packet4i >() [2/3]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pdiv< Packet4i >	(	const Packet4i &	,
		const Packet4i &
	)

{ eigen_assert(false && "packet integer division are not supported by NEON");
  return pset1<Packet4i>(0);
}

References eigen_assert, and pset1< Packet4i >().

Here is the call graph for this function:

pdiv< Packet4i >() [3/3]

template<>

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

{ return (a / b); }

pdiv< Packet8d >()

template<>

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

                                                               {
  return _mm512_div_pd(a, b);
}

pdiv< Packet8f >()

template<>

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

{ return _mm256_div_ps(a,b); }

pdiv< Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::pdiv< Packet8i >	(	const Packet8i &	,
		const Packet8i &
	)

{ eigen_assert(false && "packet integer division are not supported by AVX");
  return pset1<Packet8i>(0);
}

References eigen_assert, and pset1< Packet8i >().

Here is the call graph for this function:

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
	)

{
  typedef typename MatrixType::StorageIndex StorageIndex;
  typedef typename MatrixType::Scalar Scalar;
  typedef SparseMatrix<Scalar,DestOrder,StorageIndex> Dest;
  typedef Matrix<StorageIndex,Dynamic,1> VectorI;
  typedef evaluator<MatrixType> MatEval;
  typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
  
  MatEval matEval(mat);
  Dest& dest(_dest.derived());
  enum {
    StorageOrderMatch = int(Dest::IsRowMajor) == int(MatrixType::IsRowMajor)
  };
  
  Index size = mat.rows();
  VectorI count;
  count.resize(size);
  count.setZero();
  dest.resize(size,size);
  for(Index j = 0; j<size; ++j)
  {
    Index jp = perm ? perm[j] : j;
    for(MatIterator it(matEval,j); it; ++it)
    {
      Index i = it.index();
      Index r = it.row();
      Index c = it.col();
      Index ip = perm ? perm[i] : i;
      if(Mode==(Upper|Lower))
        count[StorageOrderMatch ? jp : ip]++;
      else if(r==c)
        count[ip]++;
      else if(( Mode==Lower && r>c) || ( Mode==Upper && r<c))
      {
        count[ip]++;
        count[jp]++;
      }
    }
  }
  Index nnz = count.sum();
  
  // reserve space
  dest.resizeNonZeros(nnz);
  dest.outerIndexPtr()[0] = 0;
  for(Index j=0; j<size; ++j)
    dest.outerIndexPtr()[j+1] = dest.outerIndexPtr()[j] + count[j];
  for(Index j=0; j<size; ++j)
    count[j] = dest.outerIndexPtr()[j];
  
  // copy data
  for(StorageIndex j = 0; j<size; ++j)
  {
    for(MatIterator it(matEval,j); it; ++it)
    {
      StorageIndex i = internal::convert_index<StorageIndex>(it.index());
      Index r = it.row();
      Index c = it.col();
      
      StorageIndex jp = perm ? perm[j] : j;
      StorageIndex ip = perm ? perm[i] : i;
      
      if(Mode==(Upper|Lower))
      {
        Index k = count[StorageOrderMatch ? jp : ip]++;
        dest.innerIndexPtr()[k] = StorageOrderMatch ? ip : jp;
        dest.valuePtr()[k] = it.value();
      }
      else if(r==c)
      {
        Index k = count[ip]++;
        dest.innerIndexPtr()[k] = ip;
        dest.valuePtr()[k] = it.value();
      }
      else if(( (Mode&Lower)==Lower && r>c) || ( (Mode&Upper)==Upper && r<c))
      {
        if(!StorageOrderMatch)
          std::swap(ip,jp);
        Index k = count[jp]++;
        dest.innerIndexPtr()[k] = ip;
        dest.valuePtr()[k] = it.value();
        k = count[ip]++;
        dest.innerIndexPtr()[k] = jp;
        dest.valuePtr()[k] = numext::conj(it.value());
      }
    }
  }
}

References Eigen::SparseMatrixBase< Derived >::derived(), Eigen::Lower, permute_symm_to_fullsymm(), and Eigen::Upper.

Referenced by permute_symm_to_fullsymm().

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

Referenced by permute_symm_to_symm().

Here is the caller graph for this function:

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
	)

{
  typedef typename MatrixType::StorageIndex StorageIndex;
  typedef typename MatrixType::Scalar Scalar;
  SparseMatrix<Scalar,DstOrder,StorageIndex>& dest(_dest.derived());
  typedef Matrix<StorageIndex,Dynamic,1> VectorI;
  typedef evaluator<MatrixType> MatEval;
  typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
 
  enum {
    SrcOrder = MatrixType::IsRowMajor ? RowMajor : ColMajor,
    StorageOrderMatch = int(SrcOrder) == int(DstOrder),
    DstMode = DstOrder==RowMajor ? (_DstMode==Upper ? Lower : Upper) : _DstMode,
    SrcMode = SrcOrder==RowMajor ? (_SrcMode==Upper ? Lower : Upper) : _SrcMode
  };
 
  MatEval matEval(mat);
  
  Index size = mat.rows();
  VectorI count(size);
  count.setZero();
  dest.resize(size,size);
  for(StorageIndex j = 0; j<size; ++j)
  {
    StorageIndex jp = perm ? perm[j] : j;
    for(MatIterator it(matEval,j); it; ++it)
    {
      StorageIndex i = it.index();
      if((int(SrcMode)==int(Lower) && i<j) || (int(SrcMode)==int(Upper) && i>j))
        continue;
                  
      StorageIndex ip = perm ? perm[i] : i;
      count[int(DstMode)==int(Lower) ? (std::min)(ip,jp) : (std::max)(ip,jp)]++;
    }
  }
  dest.outerIndexPtr()[0] = 0;
  for(Index j=0; j<size; ++j)
    dest.outerIndexPtr()[j+1] = dest.outerIndexPtr()[j] + count[j];
  dest.resizeNonZeros(dest.outerIndexPtr()[size]);
  for(Index j=0; j<size; ++j)
    count[j] = dest.outerIndexPtr()[j];
  
  for(StorageIndex j = 0; j<size; ++j)
  {
    
    for(MatIterator it(matEval,j); it; ++it)
    {
      StorageIndex i = it.index();
      if((int(SrcMode)==int(Lower) && i<j) || (int(SrcMode)==int(Upper) && i>j))
        continue;
                  
      StorageIndex jp = perm ? perm[j] : j;
      StorageIndex ip = perm? perm[i] : i;
      
      Index k = count[int(DstMode)==int(Lower) ? (std::min)(ip,jp) : (std::max)(ip,jp)]++;
      dest.innerIndexPtr()[k] = int(DstMode)==int(Lower) ? (std::max)(ip,jp) : (std::min)(ip,jp);
      
      if(!StorageOrderMatch) std::swap(ip,jp);
      if( ((int(DstMode)==int(Lower) && ip<jp) || (int(DstMode)==int(Upper) && ip>jp)))
        dest.valuePtr()[k] = numext::conj(it.value());
      else
        dest.valuePtr()[k] = it.value();
    }
  }
}

References Eigen::ColMajor, Eigen::SparseMatrixBase< Derived >::derived(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::innerIndexPtr(), Eigen::Lower, Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::outerIndexPtr(), permute_symm_to_symm(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::resize(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::resizeNonZeros(), Eigen::RowMajor, Eigen::Upper, and Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::valuePtr().

Here is the call graph for this function:

pexp()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pexp

(

const Packet &

a

)

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

References exp().

Referenced by Eigen::internal::scalar_exp_op< Scalar >::packetOp().

Here is the call graph for this function:

Here is the caller graph for this function:

pexp< Packet2d >() [1/2]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d Eigen::internal::pexp< Packet2d >

(

const Packet2d &

_x

)

{
  Packet2d x = _x;
 
  _EIGEN_DECLARE_CONST_Packet2d(1 , 1.0);
  _EIGEN_DECLARE_CONST_Packet2d(2 , 2.0);
  _EIGEN_DECLARE_CONST_Packet2d(half, 0.5);
 
  _EIGEN_DECLARE_CONST_Packet2d(exp_hi,  709.437);
  _EIGEN_DECLARE_CONST_Packet2d(exp_lo, -709.436139303);
 
  _EIGEN_DECLARE_CONST_Packet2d(cephes_LOG2EF, 1.4426950408889634073599);
 
  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p0, 1.26177193074810590878e-4);
  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p1, 3.02994407707441961300e-2);
  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p2, 9.99999999999999999910e-1);
 
  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q0, 3.00198505138664455042e-6);
  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q1, 2.52448340349684104192e-3);
  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q2, 2.27265548208155028766e-1);
  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q3, 2.00000000000000000009e0);
 
  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_C1, 0.693145751953125);
  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_C2, 1.42860682030941723212e-6);
  static const __m128i p4i_1023_0 = _mm_setr_epi32(1023, 1023, 0, 0);
 
  Packet2d tmp, fx;
  Packet4i emm0;
 
  // clamp x
  x = pmax(pmin(x, p2d_exp_hi), p2d_exp_lo);
  /* express exp(x) as exp(g + n*log(2)) */
  fx = pmadd(p2d_cephes_LOG2EF, x, p2d_half);
 
#ifdef EIGEN_VECTORIZE_SSE4_1
  fx = _mm_floor_pd(fx);
#else
  emm0 = _mm_cvttpd_epi32(fx);
  tmp  = _mm_cvtepi32_pd(emm0);
  /* if greater, substract 1 */
  Packet2d mask = _mm_cmpgt_pd(tmp, fx);
  mask = _mm_and_pd(mask, p2d_1);
  fx = psub(tmp, mask);
#endif
 
  tmp = pmul(fx, p2d_cephes_exp_C1);
  Packet2d z = pmul(fx, p2d_cephes_exp_C2);
  x = psub(x, tmp);
  x = psub(x, z);
 
  Packet2d x2 = pmul(x,x);
 
  Packet2d px = p2d_cephes_exp_p0;
  px = pmadd(px, x2, p2d_cephes_exp_p1);
  px = pmadd(px, x2, p2d_cephes_exp_p2);
  px = pmul (px, x);
 
  Packet2d qx = p2d_cephes_exp_q0;
  qx = pmadd(qx, x2, p2d_cephes_exp_q1);
  qx = pmadd(qx, x2, p2d_cephes_exp_q2);
  qx = pmadd(qx, x2, p2d_cephes_exp_q3);
 
  x = pdiv(px,psub(qx,px));
  x = pmadd(p2d_2,x,p2d_1);
 
  // build 2^n
  emm0 = _mm_cvttpd_epi32(fx);
  emm0 = _mm_add_epi32(emm0, p4i_1023_0);
  emm0 = _mm_slli_epi32(emm0, 20);
  emm0 = _mm_shuffle_epi32(emm0, _MM_SHUFFLE(1,2,0,3));
  return pmax(pmul(x, Packet2d(_mm_castsi128_pd(emm0))), _x);
}

References _EIGEN_DECLARE_CONST_Packet2d, pdiv(), pmadd(), pmax(), pmin(), pmul(), and psub().

Referenced by pexp< Packet4f >().

Here is the call graph for this function:

Here is the caller graph for this function:

pexp< Packet2d >() [2/2]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d Eigen::internal::pexp< Packet2d >

(

const Packet2d &

_x

)

{
  Packet2d x = _x;
 
  Packet2d tmp, fx;
  Packet2l emm0;
 
  // clamp x
  x = pmax(pmin(x, p2d_exp_hi), p2d_exp_lo);
  /* express exp(x) as exp(g + n*log(2)) */
  fx = pmadd(p2d_cephes_LOG2EF, x, p2d_half);
 
  fx = vec_floor(fx);
 
  tmp = pmul(fx, p2d_cephes_exp_C1);
  Packet2d z = pmul(fx, p2d_cephes_exp_C2);
  x = psub(x, tmp);
  x = psub(x, z);
 
  Packet2d x2 = pmul(x,x);
 
  Packet2d px = p2d_cephes_exp_p0;
  px = pmadd(px, x2, p2d_cephes_exp_p1);
  px = pmadd(px, x2, p2d_cephes_exp_p2);
  px = pmul (px, x);
 
  Packet2d qx = p2d_cephes_exp_q0;
  qx = pmadd(qx, x2, p2d_cephes_exp_q1);
  qx = pmadd(qx, x2, p2d_cephes_exp_q2);
  qx = pmadd(qx, x2, p2d_cephes_exp_q3);
 
  x = pdiv(px,psub(qx,px));
  x = pmadd(p2d_2,x,p2d_1);
 
  // build 2^n
  emm0 = vec_ctsl(fx, 0);
 
  static const Packet2l p2l_1023 = { 1023, 1023 };
  static const Packet2ul p2ul_52 = { 52, 52 };
 
  emm0 = emm0 + p2l_1023;
  emm0 = emm0 << reinterpret_cast<Packet2l>(p2ul_52);
 
  // Altivec's max & min operators just drop silent NaNs. Check NaNs in 
  // inputs and return them unmodified.
  Packet2ul isnumber_mask = reinterpret_cast<Packet2ul>(vec_cmpeq(_x, _x));
  return vec_sel(_x, pmax(pmul(x, reinterpret_cast<Packet2d>(emm0)), _x),
                 isnumber_mask);
}

References pdiv(), pmadd(), pmax(), pmin(), pmul(), and psub().

Here is the call graph for this function:

pexp< Packet4d >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d Eigen::internal::pexp< Packet4d >

(

const Packet4d &

_x

)

                                   {
  Packet4d x = _x;
 
  _EIGEN_DECLARE_CONST_Packet4d(1, 1.0);
  _EIGEN_DECLARE_CONST_Packet4d(2, 2.0);
  _EIGEN_DECLARE_CONST_Packet4d(half, 0.5);
 
  _EIGEN_DECLARE_CONST_Packet4d(exp_hi, 709.437);
  _EIGEN_DECLARE_CONST_Packet4d(exp_lo, -709.436139303);
 
  _EIGEN_DECLARE_CONST_Packet4d(cephes_LOG2EF, 1.4426950408889634073599);
 
  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_p0, 1.26177193074810590878e-4);
  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_p1, 3.02994407707441961300e-2);
  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_p2, 9.99999999999999999910e-1);
 
  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_q0, 3.00198505138664455042e-6);
  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_q1, 2.52448340349684104192e-3);
  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_q2, 2.27265548208155028766e-1);
  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_q3, 2.00000000000000000009e0);
 
  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_C1, 0.693145751953125);
  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_C2, 1.42860682030941723212e-6);
  _EIGEN_DECLARE_CONST_Packet4i(1023, 1023);
 
  Packet4d tmp, fx;
 
  // clamp x
  x = pmax(pmin(x, p4d_exp_hi), p4d_exp_lo);
  // Express exp(x) as exp(g + n*log(2)).
  fx = pmadd(p4d_cephes_LOG2EF, x, p4d_half);
 
  // Get the integer modulus of log(2), i.e. the "n" described above.
  fx = _mm256_floor_pd(fx);
 
  // Get the remainder modulo log(2), i.e. the "g" described above. Subtract
  // n*log(2) out in two steps, i.e. n*C1 + n*C2, C1+C2=log2 to get the last
  // digits right.
  tmp = pmul(fx, p4d_cephes_exp_C1);
  Packet4d z = pmul(fx, p4d_cephes_exp_C2);
  x = psub(x, tmp);
  x = psub(x, z);
 
  Packet4d x2 = pmul(x, x);
 
  // Evaluate the numerator polynomial of the rational interpolant.
  Packet4d px = p4d_cephes_exp_p0;
  px = pmadd(px, x2, p4d_cephes_exp_p1);
  px = pmadd(px, x2, p4d_cephes_exp_p2);
  px = pmul(px, x);
 
  // Evaluate the denominator polynomial of the rational interpolant.
  Packet4d qx = p4d_cephes_exp_q0;
  qx = pmadd(qx, x2, p4d_cephes_exp_q1);
  qx = pmadd(qx, x2, p4d_cephes_exp_q2);
  qx = pmadd(qx, x2, p4d_cephes_exp_q3);
 
  // I don't really get this bit, copied from the SSE2 routines, so...
  // TODO(gonnet): Figure out what is going on here, perhaps find a better
  // rational interpolant?
  x = _mm256_div_pd(px, psub(qx, px));
  x = pmadd(p4d_2, x, p4d_1);
 
  // Build e=2^n by constructing the exponents in a 128-bit vector and
  // shifting them to where they belong in double-precision values.
  __m128i emm0 = _mm256_cvtpd_epi32(fx);
  emm0 = _mm_add_epi32(emm0, p4i_1023);
  emm0 = _mm_shuffle_epi32(emm0, _MM_SHUFFLE(3, 1, 2, 0));
  __m128i lo = _mm_slli_epi64(emm0, 52);
  __m128i hi = _mm_slli_epi64(_mm_srli_epi64(emm0, 32), 52);
  __m256i e = _mm256_insertf128_si256(_mm256_setzero_si256(), lo, 0);
  e = _mm256_insertf128_si256(e, hi, 1);
 
  // Construct the result 2^n * exp(g) = e * x. The max is used to catch
  // non-finite values in the input.
  return pmax(pmul(x, _mm256_castsi256_pd(e)), _x);
}

References _EIGEN_DECLARE_CONST_Packet4d, _EIGEN_DECLARE_CONST_Packet4i, pmadd(), pmax(), pmin(), pmul(), and psub().

Here is the call graph for this function:

pexp< Packet4f >() [1/4]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::pexp< Packet4f >

(

const Packet4f &

_x

)

{
  Packet4f x = _x;
 
  Packet4f tmp, fx;
  Packet4i emm0;
 
  // clamp x
  x = pmax(pmin(x, p4f_exp_hi), p4f_exp_lo);
 
  // express exp(x) as exp(g + n*log(2))
  fx = pmadd(x, p4f_cephes_LOG2EF, p4f_half);
 
  fx = pfloor(fx);
 
  tmp = pmul(fx, p4f_cephes_exp_C1);
  Packet4f z = pmul(fx, p4f_cephes_exp_C2);
  x = psub(x, tmp);
  x = psub(x, z);
 
  z = pmul(x,x);
 
  Packet4f y = p4f_cephes_exp_p0;
  y = pmadd(y, x, p4f_cephes_exp_p1);
  y = pmadd(y, x, p4f_cephes_exp_p2);
  y = pmadd(y, x, p4f_cephes_exp_p3);
  y = pmadd(y, x, p4f_cephes_exp_p4);
  y = pmadd(y, x, p4f_cephes_exp_p5);
  y = pmadd(y, z, x);
  y = padd(y, p4f_1);
 
  // build 2^n
  emm0 = vec_cts(fx, 0);
  emm0 = vec_add(emm0, p4i_0x7f);
  emm0 = vec_sl(emm0, reinterpret_cast<Packet4ui>(p4i_23));
 
  // Altivec's max & min operators just drop silent NaNs. Check NaNs in 
  // inputs and return them unmodified.
  Packet4ui isnumber_mask = reinterpret_cast<Packet4ui>(vec_cmpeq(_x, _x));
  return vec_sel(_x, pmax(pmul(y, reinterpret_cast<Packet4f>(emm0)), _x),
                 isnumber_mask);
}

References padd(), pfloor(), pmadd(), pmax(), pmin(), pmul(), psub(), and y.

Here is the call graph for this function:

pexp< Packet4f >() [2/4]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::pexp< Packet4f >

(

const Packet4f &

_x

)

{
  Packet4f x = _x;
  Packet4f tmp, fx;
 
  _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f);
  _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
  _EIGEN_DECLARE_CONST_Packet4i(0x7f, 0x7f);
  _EIGEN_DECLARE_CONST_Packet4f(exp_hi,  88.3762626647950f);
  _EIGEN_DECLARE_CONST_Packet4f(exp_lo, -88.3762626647949f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_LOG2EF, 1.44269504088896341f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C1, 0.693359375f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C2, -2.12194440e-4f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p0, 1.9875691500E-4f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p1, 1.3981999507E-3f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p2, 8.3334519073E-3f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p3, 4.1665795894E-2f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p4, 1.6666665459E-1f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p5, 5.0000001201E-1f);
 
  x = vminq_f32(x, p4f_exp_hi);
  x = vmaxq_f32(x, p4f_exp_lo);
 
  /* express exp(x) as exp(g + n*log(2)) */
  fx = vmlaq_f32(p4f_half, x, p4f_cephes_LOG2EF);
 
  /* perform a floorf */
  tmp = vcvtq_f32_s32(vcvtq_s32_f32(fx));
 
  /* if greater, substract 1 */
  Packet4ui mask = vcgtq_f32(tmp, fx);
  mask = vandq_u32(mask, vreinterpretq_u32_f32(p4f_1));
 
  fx = vsubq_f32(tmp, vreinterpretq_f32_u32(mask));
 
  tmp = vmulq_f32(fx, p4f_cephes_exp_C1);
  Packet4f z = vmulq_f32(fx, p4f_cephes_exp_C2);
  x = vsubq_f32(x, tmp);
  x = vsubq_f32(x, z);
 
  Packet4f y = vmulq_f32(p4f_cephes_exp_p0, x);
  z = vmulq_f32(x, x);
  y = vaddq_f32(y, p4f_cephes_exp_p1);
  y = vmulq_f32(y, x);
  y = vaddq_f32(y, p4f_cephes_exp_p2);
  y = vmulq_f32(y, x);
  y = vaddq_f32(y, p4f_cephes_exp_p3);
  y = vmulq_f32(y, x);
  y = vaddq_f32(y, p4f_cephes_exp_p4);
  y = vmulq_f32(y, x);
  y = vaddq_f32(y, p4f_cephes_exp_p5);
 
  y = vmulq_f32(y, z);
  y = vaddq_f32(y, x);
  y = vaddq_f32(y, p4f_1);
 
  /* build 2^n */
  int32x4_t mm;
  mm = vcvtq_s32_f32(fx);
  mm = vaddq_s32(mm, p4i_0x7f);
  mm = vshlq_n_s32(mm, 23);
  Packet4f pow2n = vreinterpretq_f32_s32(mm);
 
  y = vmulq_f32(y, pow2n);
  return y;
}

References _EIGEN_DECLARE_CONST_Packet4f, _EIGEN_DECLARE_CONST_Packet4i, and y.

pexp< Packet4f >() [3/4]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::pexp< Packet4f >

(

const Packet4f &

_x

)

{
  Packet4f x = _x;
  _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f);
  _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
  _EIGEN_DECLARE_CONST_Packet4i(0x7f, 0x7f);
 
 
  _EIGEN_DECLARE_CONST_Packet4f(exp_hi,  88.3762626647950f);
  _EIGEN_DECLARE_CONST_Packet4f(exp_lo, -88.3762626647949f);
 
  _EIGEN_DECLARE_CONST_Packet4f(cephes_LOG2EF, 1.44269504088896341f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C1, 0.693359375f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C2, -2.12194440e-4f);
 
  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p0, 1.9875691500E-4f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p1, 1.3981999507E-3f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p2, 8.3334519073E-3f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p3, 4.1665795894E-2f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p4, 1.6666665459E-1f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p5, 5.0000001201E-1f);
 
  Packet4f tmp, fx;
  Packet4i emm0;
 
  // clamp x
  x = pmax(pmin(x, p4f_exp_hi), p4f_exp_lo);
 
  /* express exp(x) as exp(g + n*log(2)) */
  fx = pmadd(x, p4f_cephes_LOG2EF, p4f_half);
 
#ifdef EIGEN_VECTORIZE_SSE4_1
  fx = _mm_floor_ps(fx);
#else
  emm0 = _mm_cvttps_epi32(fx);
  tmp  = _mm_cvtepi32_ps(emm0);
  /* if greater, substract 1 */
  Packet4f mask = _mm_cmpgt_ps(tmp, fx);
  mask = _mm_and_ps(mask, p4f_1);
  fx = psub(tmp, mask);
#endif
 
  tmp = pmul(fx, p4f_cephes_exp_C1);
  Packet4f z = pmul(fx, p4f_cephes_exp_C2);
  x = psub(x, tmp);
  x = psub(x, z);
 
  z = pmul(x,x);
 
  Packet4f y = p4f_cephes_exp_p0;
  y = pmadd(y, x, p4f_cephes_exp_p1);
  y = pmadd(y, x, p4f_cephes_exp_p2);
  y = pmadd(y, x, p4f_cephes_exp_p3);
  y = pmadd(y, x, p4f_cephes_exp_p4);
  y = pmadd(y, x, p4f_cephes_exp_p5);
  y = pmadd(y, z, x);
  y = padd(y, p4f_1);
 
  // build 2^n
  emm0 = _mm_cvttps_epi32(fx);
  emm0 = _mm_add_epi32(emm0, p4i_0x7f);
  emm0 = _mm_slli_epi32(emm0, 23);
  return pmax(pmul(y, Packet4f(_mm_castsi128_ps(emm0))), _x);
}

References _EIGEN_DECLARE_CONST_Packet4f, _EIGEN_DECLARE_CONST_Packet4i, padd(), pmadd(), pmax(), pmin(), pmul(), psub(), and y.

Here is the call graph for this function:

pexp< Packet4f >() [4/4]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::pexp< Packet4f >

(

const Packet4f &

x

)

{
  Packet4f res;
  res.v4f[0] = pexp<Packet2d>(x.v4f[0]);
  res.v4f[1] = pexp<Packet2d>(x.v4f[1]);
  return res;
}

References pexp< Packet2d >(), and Eigen::internal::Packet4f::v4f.

Here is the call graph for this function:

pexp< Packet8f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f Eigen::internal::pexp< Packet8f >

(

const Packet8f &

_x

)

                                   {
  _EIGEN_DECLARE_CONST_Packet8f(1, 1.0f);
  _EIGEN_DECLARE_CONST_Packet8f(half, 0.5f);
  _EIGEN_DECLARE_CONST_Packet8f(127, 127.0f);
 
  _EIGEN_DECLARE_CONST_Packet8f(exp_hi, 88.3762626647950f);
  _EIGEN_DECLARE_CONST_Packet8f(exp_lo, -88.3762626647949f);
 
  _EIGEN_DECLARE_CONST_Packet8f(cephes_LOG2EF, 1.44269504088896341f);
 
  _EIGEN_DECLARE_CONST_Packet8f(cephes_exp_p0, 1.9875691500E-4f);
  _EIGEN_DECLARE_CONST_Packet8f(cephes_exp_p1, 1.3981999507E-3f);
  _EIGEN_DECLARE_CONST_Packet8f(cephes_exp_p2, 8.3334519073E-3f);
  _EIGEN_DECLARE_CONST_Packet8f(cephes_exp_p3, 4.1665795894E-2f);
  _EIGEN_DECLARE_CONST_Packet8f(cephes_exp_p4, 1.6666665459E-1f);
  _EIGEN_DECLARE_CONST_Packet8f(cephes_exp_p5, 5.0000001201E-1f);
 
  // Clamp x.
  Packet8f x = pmax(pmin(_x, p8f_exp_hi), p8f_exp_lo);
 
  // Express exp(x) as exp(m*ln(2) + r), start by extracting
  // m = floor(x/ln(2) + 0.5).
  Packet8f m = _mm256_floor_ps(pmadd(x, p8f_cephes_LOG2EF, p8f_half));
 
// Get r = x - m*ln(2). If no FMA instructions are available, m*ln(2) is
// subtracted out in two parts, m*C1+m*C2 = m*ln(2), to avoid accumulating
// truncation errors. Note that we don't use the "pmadd" function here to
// ensure that a precision-preserving FMA instruction is used.
#ifdef EIGEN_VECTORIZE_FMA
  _EIGEN_DECLARE_CONST_Packet8f(nln2, -0.6931471805599453f);
  Packet8f r = _mm256_fmadd_ps(m, p8f_nln2, x);
#else
  _EIGEN_DECLARE_CONST_Packet8f(cephes_exp_C1, 0.693359375f);
  _EIGEN_DECLARE_CONST_Packet8f(cephes_exp_C2, -2.12194440e-4f);
  Packet8f r = psub(x, pmul(m, p8f_cephes_exp_C1));
  r = psub(r, pmul(m, p8f_cephes_exp_C2));
#endif
 
  Packet8f r2 = pmul(r, r);
 
  // TODO(gonnet): Split into odd/even polynomials and try to exploit
  //               instruction-level parallelism.
  Packet8f y = p8f_cephes_exp_p0;
  y = pmadd(y, r, p8f_cephes_exp_p1);
  y = pmadd(y, r, p8f_cephes_exp_p2);
  y = pmadd(y, r, p8f_cephes_exp_p3);
  y = pmadd(y, r, p8f_cephes_exp_p4);
  y = pmadd(y, r, p8f_cephes_exp_p5);
  y = pmadd(y, r2, r);
  y = padd(y, p8f_1);
 
  // Build emm0 = 2^m.
  Packet8i emm0 = _mm256_cvttps_epi32(padd(m, p8f_127));
  emm0 = pshiftleft(emm0, 23);
 
  // Return 2^m * exp(r).
  return pmax(pmul(y, _mm256_castsi256_ps(emm0)), _x);
}

References _EIGEN_DECLARE_CONST_Packet8f, padd(), pmadd(), pmax(), pmin(), pmul(), pshiftleft(), psub(), and y.

Here is the call graph for this function:

pfirst()

template<typename Packet >

EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type Eigen::internal::pfirst ( const Packet &  a )

inline

{ return a; }

Referenced by pfirst< Packet4cf >(), predux< Packet16f >(), predux< Packet1cd >(), predux< Packet2cf >(), predux< Packet2d >(), predux< Packet4f >(), predux< Packet4i >(), predux< Packet8d >(), predux_max< Packet16f >(), predux_max< Packet2d >(), predux_max< Packet4d >(), predux_max< Packet4f >(), predux_max< Packet4i >(), predux_max< Packet8d >(), predux_max< Packet8f >(), predux_min< Packet16f >(), predux_min< Packet2d >(), predux_min< Packet4d >(), predux_min< Packet4f >(), predux_min< Packet4i >(), predux_min< Packet8d >(), predux_min< Packet8f >(), predux_mul< Packet16f >(), predux_mul< Packet1cd >(), predux_mul< Packet2cf >(), predux_mul< Packet2d >(), predux_mul< Packet4d >(), predux_mul< Packet4f >(), predux_mul< Packet8d >(), predux_mul< Packet8f >(), Eigen::internal::general_matrix_vector_product< Index, LhsScalar, LhsMapper, ColMajor, ConjugateLhs, RhsScalar, RhsMapper, ConjugateRhs, Version >::run(), Eigen::numext::sqrt(), and Eigen::numext::sqrt().

Here is the caller graph for this function:

pfirst< Packet16f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet16f >

(

const Packet16f &

a

)

                                                                {
  return _mm_cvtss_f32(_mm512_extractf32x4_ps(a, 0));
}

pfirst< Packet16i >()

template<>

EIGEN_STRONG_INLINE int Eigen::internal::pfirst< Packet16i >

(

const Packet16i &

a

)

                                                              {
  return _mm_extract_epi32(_mm512_extracti32x4_epi32(a, 0), 0);
}

pfirst< Packet1cd >() [1/2]

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::pfirst< Packet1cd >

(

const Packet1cd &

a

)

{
  EIGEN_ALIGN16 double res[2];
  _mm_store_pd(res, a.v);
  return std::complex<double>(res[0],res[1]);
}

References EIGEN_ALIGN16.

pfirst< Packet1cd >() [2/2]

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::pfirst< Packet1cd >

(

const Packet1cd &

a

)

{
  std::complex<double> EIGEN_ALIGN16 res;
  pstore<std::complex<double> >(&res, a);
 
  return res;
}

References EIGEN_ALIGN16.

pfirst< Packet2cd >()

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::pfirst< Packet2cd >

(

const Packet2cd &

a

)

{
  __m128d low = _mm256_extractf128_pd(a.v, 0);
  EIGEN_ALIGN16 double res[2];
  _mm_store_pd(res, low);
  return std::complex<double>(res[0],res[1]);
}

References EIGEN_ALIGN16.

pfirst< Packet2cf >() [1/4]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::pfirst< Packet2cf >

(

const Packet2cf &

a

)

{
  std::complex<float> EIGEN_ALIGN16 res[2];
  pstore((float *)&res, a.v);
 
  return res[0];
}

References EIGEN_ALIGN16, and pstore().

Referenced by predux< Packet2cf >(), and predux_mul< Packet2cf >().

Here is the call graph for this function:

Here is the caller graph for this function:

pfirst< Packet2cf >() [2/4]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::pfirst< Packet2cf >

(

const Packet2cf &

a

)

{
  std::complex<float> EIGEN_ALIGN16 x[2];
  vst1q_f32((float *)x, a.v);
  return x[0];
}

References EIGEN_ALIGN16.

pfirst< Packet2cf >() [3/4]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::pfirst< Packet2cf >

(

const Packet2cf &

a

)

{
  #if EIGEN_GNUC_AT_MOST(4,3)
  // Workaround gcc 4.2 ICE - this is not performance wise ideal, but who cares...
  // This workaround also fix invalid code generation with gcc 4.3
  EIGEN_ALIGN16 std::complex<float> res[2];
  _mm_store_ps((float*)res, a.v);
  return res[0];
  #else
  std::complex<float> res;
  _mm_storel_pi((__m64*)&res, a.v);
  return res;
  #endif
}

References EIGEN_ALIGN16.

pfirst< Packet2cf >() [4/4]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::pfirst< Packet2cf >

(

const Packet2cf &

a

)

{
  std::complex<float> EIGEN_ALIGN16 res[2];
  pstore<std::complex<float> >(res, a);
 
  return res[0];
}

References EIGEN_ALIGN16.

pfirst< Packet2d >() [1/2]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::pfirst< Packet2d >

(

const Packet2d &

a

)

{ return _mm_cvtsd_f64(a); }

Referenced by predux< Packet2d >(), predux_max< Packet2d >(), predux_min< Packet2d >(), and predux_mul< Packet2d >().

Here is the caller graph for this function:

pfirst< Packet2d >() [2/2]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::pfirst< Packet2d >

(

const Packet2d &

a

)

{ double EIGEN_ALIGN16 x[2]; pstore(x, a); return x[0]; }

References EIGEN_ALIGN16, and pstore().

Here is the call graph for this function:

pfirst< Packet4cf >()

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::pfirst< Packet4cf >

(

const Packet4cf &

a

)

{
  return pfirst(Packet2cf(_mm256_castps256_ps128(a.v)));
}

References pfirst().

Here is the call graph for this function:

pfirst< Packet4d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::pfirst< Packet4d >

(

const Packet4d &

a

)

                                                                          {
  return _mm_cvtsd_f64(_mm256_castpd256_pd128(a));
}

pfirst< Packet4f >() [1/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet4f >

(

const Packet4f &

a

)

{ float EIGEN_ALIGN16 x; vec_ste(a, 0, &x); return x; }

References EIGEN_ALIGN16.

Referenced by predux< Packet4f >(), predux_max< Packet4f >(), predux_min< Packet4f >(), and predux_mul< Packet4f >().

Here is the caller graph for this function:

pfirst< Packet4f >() [2/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet4f >

(

const Packet4f &

a

)

{ float   EIGEN_ALIGN16 x[4]; vst1q_f32(x, a); return x[0]; }

References EIGEN_ALIGN16.

pfirst< Packet4f >() [3/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet4f >

(

const Packet4f &

a

)

{ return _mm_cvtss_f32(a); }

pfirst< Packet4f >() [4/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet4f >

(

const Packet4f &

a

)

{ float  EIGEN_ALIGN16 x[2]; vec_st2f(a.v4f[0], &x[0]); return x[0]; }

References EIGEN_ALIGN16.

pfirst< Packet4i >() [1/4]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::pfirst< Packet4i >

(

const Packet4i &

a

)

{ int   EIGEN_ALIGN16 x; vec_ste(a, 0, &x); return x; }

References EIGEN_ALIGN16.

Referenced by predux< Packet4i >(), predux_max< Packet4i >(), and predux_min< Packet4i >().

Here is the caller graph for this function:

pfirst< Packet4i >() [2/4]

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::pfirst< Packet4i >

(

const Packet4i &

a

)

{ int32_t EIGEN_ALIGN16 x[4]; vst1q_s32(x, a); return x[0]; }

References EIGEN_ALIGN16.

pfirst< Packet4i >() [3/4]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::pfirst< Packet4i >

(

const Packet4i &

a

)

{ return _mm_cvtsi128_si32(a); }

pfirst< Packet4i >() [4/4]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::pfirst< Packet4i >

(

const Packet4i &

a

)

{ int    EIGEN_ALIGN16 x[4]; pstore(x, a); return x[0]; }

References EIGEN_ALIGN16, and pstore().

Here is the call graph for this function:

pfirst< Packet8d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::pfirst< Packet8d >

(

const Packet8d &

a

)

                                                               {
  return _mm_cvtsd_f64(_mm256_extractf128_pd(_mm512_extractf64x4_pd(a, 0), 0));
}

pfirst< Packet8f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet8f >

(

const Packet8f &

a

)

                                                                          {
  return _mm_cvtss_f32(_mm256_castps256_ps128(a));
}

pfirst< Packet8i >()

template<>

EIGEN_STRONG_INLINE int Eigen::internal::pfirst< Packet8i >

(

const Packet8i &

a

)

                                                                          {
  return _mm_cvtsi128_si32(_mm256_castsi256_si128(a));
}

pfloor()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pfloor

(

const Packet &

a

)

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

References floor(), and Eigen::numext::floor().

Referenced by pexp< Packet4f >().

Here is the call graph for this function:

Here is the caller graph for this function:

pfloor< Packet2d >()

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pfloor< Packet2d >

(

const Packet2d &

a

)

{ return vec_floor(a); }

pfloor< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pfloor< Packet4d >

(

const Packet4d &

a

)

{ return _mm256_floor_pd(a); }

pfloor< Packet4f >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pfloor< Packet4f >

(

const Packet4f &

a

)

{ return vec_floor(a); }

pfloor< Packet4f >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pfloor< Packet4f >

(

const Packet4f &

a

)

{
  Packet4f res;
  res.v4f[0] = vec_floor(a.v4f[0]);
  res.v4f[1] = vec_floor(a.v4f[1]);
  return res;
}

References Eigen::internal::Packet4f::v4f.

pfloor< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pfloor< Packet8f >

(

const Packet8f &

a

)

{ return _mm256_floor_ps(a); }

pgather()

template<typename Scalar , typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pgather ( const Scalar *  from, Index    )

inline

 { return ploadu<Packet>(from); }

pgather< double, Packet2d >() [1/2]

template<>

EIGEN_DEVICE_FUNC Packet2d Eigen::internal::pgather< double, Packet2d > ( const double *  from, Index  stride  )

inline

{
 return _mm_set_pd(from[1*stride], from[0*stride]);
}

pgather< double, Packet2d >() [2/2]

template<>

EIGEN_DEVICE_FUNC Packet2d Eigen::internal::pgather< double, Packet2d > ( const double *  from, Index  stride  )

inline

{
  double EIGEN_ALIGN16 af[2];
  af[0] = from[0*stride];
  af[1] = from[1*stride];
 return pload<Packet2d>(af);
}

References EIGEN_ALIGN16, and pload< Packet2d >().

Here is the call graph for this function:

pgather< double, Packet4d >()

template<>

EIGEN_DEVICE_FUNC Packet4d Eigen::internal::pgather< double, Packet4d > ( const double *  from, Index  stride  )

inline

{
  return _mm256_set_pd(from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
}

pgather< double, Packet8d >()

template<>

EIGEN_DEVICE_FUNC Packet8d Eigen::internal::pgather< double, Packet8d > ( const double *  from, Index  stride  )

inline

                                                                          {
  Packet8i stride_vector = _mm256_set1_epi32(stride);
  Packet8i stride_multiplier = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
  Packet8i indices = _mm256_mullo_epi32(stride_vector, stride_multiplier);
 
  return _mm512_i32gather_pd(indices, from, 8);
}

pgather< float, Packet16f >()

template<>

EIGEN_DEVICE_FUNC Packet16f Eigen::internal::pgather< float, Packet16f > ( const float *  from, Index  stride  )

inline

                                                                           {
  Packet16i stride_vector = _mm512_set1_epi32(stride);
  Packet16i stride_multiplier =
      _mm512_set_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
  Packet16i indices = _mm512_mullo_epi32(stride_vector, stride_multiplier);
 
  return _mm512_i32gather_ps(indices, from, 4);
}

pgather< float, Packet4f >() [1/4]

template<>

EIGEN_DEVICE_FUNC Packet4f Eigen::internal::pgather< float, Packet4f > ( const float *  from, Index  stride  )

inline

{
  float EIGEN_ALIGN16 af[4];
  af[0] = from[0*stride];
  af[1] = from[1*stride];
  af[2] = from[2*stride];
  af[3] = from[3*stride];
 return pload<Packet4f>(af);
}

References EIGEN_ALIGN16, and pload< Packet4f >().

Here is the call graph for this function:

pgather< float, Packet4f >() [2/4]

template<>

EIGEN_DEVICE_FUNC Packet4f Eigen::internal::pgather< float, Packet4f > ( const float *  from, Index  stride  )

inline

{
  Packet4f res = pset1<Packet4f>(0.f);
  res = vsetq_lane_f32(from[0*stride], res, 0);
  res = vsetq_lane_f32(from[1*stride], res, 1);
  res = vsetq_lane_f32(from[2*stride], res, 2);
  res = vsetq_lane_f32(from[3*stride], res, 3);
  return res;
}

References pset1< Packet4f >().

Here is the call graph for this function:

pgather< float, Packet4f >() [3/4]

template<>

EIGEN_DEVICE_FUNC Packet4f Eigen::internal::pgather< float, Packet4f > ( const float *  from, Index  stride  )

inline

{
 return _mm_set_ps(from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
}

pgather< float, Packet4f >() [4/4]

template<>

EIGEN_DEVICE_FUNC Packet4f Eigen::internal::pgather< float, Packet4f > ( const float *  from, Index  stride  )

inline

{
  float EIGEN_ALIGN16 ai[4];
  ai[0] = from[0*stride];
  ai[1] = from[1*stride];
  ai[2] = from[2*stride];
  ai[3] = from[3*stride];
 return pload<Packet4f>(ai);
}

References EIGEN_ALIGN16, and pload< Packet4f >().

Here is the call graph for this function:

pgather< float, Packet8f >()

template<>

EIGEN_DEVICE_FUNC Packet8f Eigen::internal::pgather< float, Packet8f > ( const float *  from, Index  stride  )

inline

{
  return _mm256_set_ps(from[7*stride], from[6*stride], from[5*stride], from[4*stride],
                       from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
}

pgather< int, Packet4i >() [1/3]

template<>

EIGEN_DEVICE_FUNC Packet4i Eigen::internal::pgather< int, Packet4i > ( const int *  from, Index  stride  )

inline

{
  int EIGEN_ALIGN16 ai[4];
  ai[0] = from[0*stride];
  ai[1] = from[1*stride];
  ai[2] = from[2*stride];
  ai[3] = from[3*stride];
 return pload<Packet4i>(ai);
}

References EIGEN_ALIGN16, and pload< Packet4i >().

Here is the call graph for this function:

pgather< int, Packet4i >() [2/3]

template<>

EIGEN_DEVICE_FUNC Packet4i Eigen::internal::pgather< int, Packet4i > ( const int *  from, Index  stride  )

inline

{
 return _mm_set_epi32(from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
 }

pgather< int, Packet4i >() [3/3]

template<>

EIGEN_DEVICE_FUNC Packet4i Eigen::internal::pgather< int, Packet4i > ( const int *  from, Index  stride  )

inline

{
  int EIGEN_ALIGN16 ai[4];
  ai[0] = from[0*stride];
  ai[1] = from[1*stride];
  ai[2] = from[2*stride];
  ai[3] = from[3*stride];
 return pload<Packet4i>(ai);
}

References EIGEN_ALIGN16, and pload< Packet4i >().

Here is the call graph for this function:

pgather< int32_t, Packet4i >()

template<>

EIGEN_DEVICE_FUNC Packet4i Eigen::internal::pgather< int32_t, Packet4i > ( const int32_t *  from, Index  stride  )

inline

{
  Packet4i res = pset1<Packet4i>(0);
  res = vsetq_lane_s32(from[0*stride], res, 0);
  res = vsetq_lane_s32(from[1*stride], res, 1);
  res = vsetq_lane_s32(from[2*stride], res, 2);
  res = vsetq_lane_s32(from[3*stride], res, 3);
  return res;
}

References pset1< Packet4i >().

Here is the call graph for this function:

pgather< std::complex< double >, Packet1cd >()

template<>

EIGEN_DEVICE_FUNC Packet1cd Eigen::internal::pgather< std::complex< double >, Packet1cd > ( const std::complex< double > *  from, Index stride  EIGEN_UNUSED  )

inline

{
  return pload<Packet1cd>(from);
}

References pload< Packet1cd >().

Here is the call graph for this function:

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

{
  return Packet2cd(_mm256_set_pd(std::imag(from[1*stride]), std::real(from[1*stride]),
         std::imag(from[0*stride]), std::real(from[0*stride])));
}

pgather< std::complex< float >, Packet2cf >() [1/4]

template<>

EIGEN_DEVICE_FUNC Packet2cf Eigen::internal::pgather< std::complex< float >, Packet2cf > ( const std::complex< float > *  from, Index  stride  )

inline

{
  std::complex<float> EIGEN_ALIGN16 af[2];
  af[0] = from[0*stride];
  af[1] = from[1*stride];
  return pload<Packet2cf>(af);
}

References EIGEN_ALIGN16, and pload< Packet2cf >().

Here is the call graph for this function:

pgather< std::complex< float >, Packet2cf >() [2/4]

template<>

EIGEN_DEVICE_FUNC Packet2cf Eigen::internal::pgather< std::complex< float >, Packet2cf > ( const std::complex< float > *  from, Index  stride  )

inline

{
  Packet4f res = pset1<Packet4f>(0.f);
  res = vsetq_lane_f32(std::real(from[0*stride]), res, 0);
  res = vsetq_lane_f32(std::imag(from[0*stride]), res, 1);
  res = vsetq_lane_f32(std::real(from[1*stride]), res, 2);
  res = vsetq_lane_f32(std::imag(from[1*stride]), res, 3);
  return Packet2cf(res);
}

References pset1< Packet4f >().

Here is the call graph for this function:

pgather< std::complex< float >, Packet2cf >() [3/4]

template<>

EIGEN_DEVICE_FUNC Packet2cf Eigen::internal::pgather< std::complex< float >, Packet2cf > ( const std::complex< float > *  from, Index  stride  )

inline

{
  return Packet2cf(_mm_set_ps(std::imag(from[1*stride]), std::real(from[1*stride]),
                              std::imag(from[0*stride]), std::real(from[0*stride])));
}

pgather< std::complex< float >, Packet2cf >() [4/4]

template<>

EIGEN_DEVICE_FUNC Packet2cf Eigen::internal::pgather< std::complex< float >, Packet2cf > ( const std::complex< float > *  from, Index  stride  )

inline

{
  std::complex<float> EIGEN_ALIGN16 af[2];
  af[0] = from[0*stride];
  af[1] = from[1*stride];
  return pload<Packet2cf>(af);
}

References EIGEN_ALIGN16, and pload< Packet2cf >().

Here is the call graph for this function:

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

{
  return Packet4cf(_mm256_set_ps(std::imag(from[3*stride]), std::real(from[3*stride]),
                                 std::imag(from[2*stride]), std::real(from[2*stride]),
                                 std::imag(from[1*stride]), std::real(from[1*stride]),
                                 std::imag(from[0*stride]), std::real(from[0*stride])));
}

pinsertfirst() [1/9]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pinsertfirst ( const Packet &  a, typename unpacket_traits< Packet >::type  b  )

inline

{
  // Default implementation based on pblend.
  // It must be specialized for higher performance.
  Selector<unpacket_traits<Packet>::size> mask;
  mask.select[0] = true;
  // This for loop should be optimized away by the compiler.
  for(Index i=1; i<unpacket_traits<Packet>::size; ++i)
    mask.select[i] = false;
  return pblend(mask, pset1<Packet>(b), a);
}

References pblend(), and Eigen::internal::Selector< N >::select.

Here is the call graph for this function:

pinsertfirst() [2/9]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pinsertfirst	(	const Packet1cd &	,
		std::complex< double >	b
	)

{
  return pset1<Packet1cd>(b);
}

References pset1< Packet1cd >().

Here is the call graph for this function:

pinsertfirst() [3/9]

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pinsertfirst	(	const Packet2cd &	a,
		std::complex< double >	b
	)

{
  return Packet2cd(_mm256_blend_pd(a.v,pset1<Packet2cd>(b).v,1|2));
}

References pset1< Packet2cd >(), and Eigen::internal::Packet2cd::v.

Here is the call graph for this function:

pinsertfirst() [4/9]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pinsertfirst	(	const Packet2cf &	a,
		std::complex< float >	b
	)

{
  return Packet2cf(_mm_loadl_pi(a.v, reinterpret_cast<const __m64*>(&b)));
}

pinsertfirst() [5/9]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pinsertfirst	(	const Packet2d &	a,
		double	b
	)

{
#ifdef EIGEN_VECTORIZE_SSE4_1
  return _mm_blend_pd(a,pset1<Packet2d>(b),1);
#else
  return _mm_move_sd(a, _mm_load_sd(&b));
#endif
}

References pset1< Packet2d >().

Here is the call graph for this function:

pinsertfirst() [6/9]

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pinsertfirst	(	const Packet4cf &	a,
		std::complex< float >	b
	)

{
  return Packet4cf(_mm256_blend_ps(a.v,pset1<Packet4cf>(b).v,1|2));
}

References pset1< Packet4cf >(), and Eigen::internal::Packet4cf::v.

Referenced by Eigen::internal::linspaced_op_impl< Scalar, Packet, false >::packetOp().

Here is the call graph for this function:

Here is the caller graph for this function:

pinsertfirst() [7/9]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pinsertfirst	(	const Packet4d &	a,
		double	b
	)

{
  return _mm256_blend_pd(a,pset1<Packet4d>(b),1);
}

References pset1< Packet4d >().

Here is the call graph for this function:

pinsertfirst() [8/9]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pinsertfirst	(	const Packet4f &	a,
		float	b
	)

{
#ifdef EIGEN_VECTORIZE_SSE4_1
  return _mm_blend_ps(a,pset1<Packet4f>(b),1);
#else
  return _mm_move_ss(a, _mm_load_ss(&b));
#endif
}

References pset1< Packet4f >().

Here is the call graph for this function:

pinsertfirst() [9/9]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pinsertfirst	(	const Packet8f &	a,
		float	b
	)

{
  return _mm256_blend_ps(a,pset1<Packet8f>(b),1);
}

References pset1< Packet8f >().

Here is the call graph for this function:

pinsertlast() [1/9]

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pinsertlast ( const Packet &  a, typename unpacket_traits< Packet >::type  b  )

inline

{
  // Default implementation based on pblend.
  // It must be specialized for higher performance.
  Selector<unpacket_traits<Packet>::size> mask;
  // This for loop should be optimized away by the compiler.
  for(Index i=0; i<unpacket_traits<Packet>::size-1; ++i)
    mask.select[i] = false;
  mask.select[unpacket_traits<Packet>::size-1] = true;
  return pblend(mask, pset1<Packet>(b), a);
}

References pblend(), and Eigen::internal::Selector< N >::select.

Here is the call graph for this function:

pinsertlast() [2/9]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pinsertlast	(	const Packet1cd &	,
		std::complex< double >	b
	)

{
  return pset1<Packet1cd>(b);
}

References pset1< Packet1cd >().

Here is the call graph for this function:

pinsertlast() [3/9]

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pinsertlast	(	const Packet2cd &	a,
		std::complex< double >	b
	)

{
  return Packet2cd(_mm256_blend_pd(a.v,pset1<Packet2cd>(b).v,(1<<3)|(1<<2)));
}

References pset1< Packet2cd >(), and Eigen::internal::Packet2cd::v.

Here is the call graph for this function:

pinsertlast() [4/9]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pinsertlast	(	const Packet2cf &	a,
		std::complex< float >	b
	)

{
  return Packet2cf(_mm_loadh_pi(a.v, reinterpret_cast<const __m64*>(&b)));
}

pinsertlast() [5/9]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pinsertlast	(	const Packet2d &	a,
		double	b
	)

{
#ifdef EIGEN_VECTORIZE_SSE4_1
  return _mm_blend_pd(a,pset1<Packet2d>(b),(1<<1));
#else
  const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0x0,0x0,0xFFFFFFFF,0xFFFFFFFF));
  return _mm_or_pd(_mm_andnot_pd(mask, a), _mm_and_pd(mask, pset1<Packet2d>(b)));
#endif
}

References pset1< Packet2d >().

Here is the call graph for this function:

pinsertlast() [6/9]

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pinsertlast	(	const Packet4cf &	a,
		std::complex< float >	b
	)

{
  return Packet4cf(_mm256_blend_ps(a.v,pset1<Packet4cf>(b).v,(1<<7)|(1<<6)));
}

References pset1< Packet4cf >(), and Eigen::internal::Packet4cf::v.

Referenced by Eigen::internal::linspaced_op_impl< Scalar, Packet, false >::packetOp().

Here is the call graph for this function:

Here is the caller graph for this function:

pinsertlast() [7/9]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pinsertlast	(	const Packet4d &	a,
		double	b
	)

{
  return _mm256_blend_pd(a,pset1<Packet4d>(b),(1<<3));
}

References pset1< Packet4d >().

Here is the call graph for this function:

pinsertlast() [8/9]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pinsertlast	(	const Packet4f &	a,
		float	b
	)

{
#ifdef EIGEN_VECTORIZE_SSE4_1
  return _mm_blend_ps(a,pset1<Packet4f>(b),(1<<3));
#else
  const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(0x0,0x0,0x0,0xFFFFFFFF));
  return _mm_or_ps(_mm_andnot_ps(mask, a), _mm_and_ps(mask, pset1<Packet4f>(b)));
#endif
}

References pset1< Packet4f >().

Here is the call graph for this function:

pinsertlast() [9/9]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pinsertlast	(	const Packet8f &	a,
		float	b
	)

{
  return _mm256_blend_ps(a,pset1<Packet8f>(b),(1<<7));
}

References pset1< Packet8f >().

Here is the call graph for this function:

pload()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pload ( const typename unpacket_traits< Packet >::type *  from )

inline

{ return *from; }

pload1()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pload1 ( const typename unpacket_traits< Packet >::type *  a )

inline

{ return pset1<Packet>(*a); }

pload1< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pload1< Packet16f >

(

const float *

from

)

                                                                   {
  return _mm512_broadcastss_ps(_mm_load_ps1(from));
}

pload1< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pload1< Packet4d >

(

const double *

from

)

{ return _mm256_broadcast_sd(from); }

pload1< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pload1< Packet8d >

(

const double *

from

)

                                                                  {
  return _mm512_broadcastsd_pd(_mm_load_pd1(from));
}

pload1< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pload1< Packet8f >

(

const float *

from

)

{ return _mm256_broadcast_ss(from); }

pload< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pload< Packet16f >

(

const float *

from

)

                                                                  {
  EIGEN_DEBUG_ALIGNED_LOAD return _mm512_load_ps(from);
}

References EIGEN_DEBUG_ALIGNED_LOAD.

pload< Packet16i >()

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::pload< Packet16i >

(

const int *

from

)

                                                                {
  EIGEN_DEBUG_ALIGNED_LOAD return _mm512_load_si512(
      reinterpret_cast<const __m512i*>(from));
}

References EIGEN_DEBUG_ALIGNED_LOAD.

pload< Packet1cd >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pload< Packet1cd >

(

const std::complex< double > *

from

)

{ EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>((const double*)from)); }

References EIGEN_DEBUG_ALIGNED_LOAD, and pload< Packet2d >().

Referenced by pgather< std::complex< double >, Packet1cd >().

Here is the call graph for this function:

Here is the caller graph for this function:

pload< Packet1cd >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pload< Packet1cd >

(

const std::complex< double > *

from

)

{ EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>((const double*)from)); }

References EIGEN_DEBUG_ALIGNED_LOAD, and pload< Packet2d >().

Here is the call graph for this function:

pload< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pload< Packet2cd >

(

const std::complex< double > *

from

)

{ EIGEN_DEBUG_ALIGNED_LOAD return Packet2cd(pload<Packet4d>((const double*)from)); }

References EIGEN_DEBUG_ALIGNED_LOAD, and pload< Packet4d >().

Here is the call graph for this function:

pload< Packet2cf >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pload< Packet2cf >

(

const std::complex< float > *

from

)

{ return Packet2cf(pload<Packet4f>((const float *) from)); }

References pload< Packet4f >().

Referenced by pgather< std::complex< float >, Packet2cf >().

Here is the call graph for this function:

Here is the caller graph for this function:

pload< Packet2cf >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pload< Packet2cf >

(

const std::complex< float > *

from

)

{ EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>((const float*)from)); }

References EIGEN_DEBUG_ALIGNED_LOAD, and pload< Packet4f >().

Here is the call graph for this function:

pload< Packet2cf >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pload< Packet2cf >

(

const std::complex< float > *

from

)

{ EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>(&numext::real_ref(*from))); }

References EIGEN_DEBUG_ALIGNED_LOAD, pload< Packet4f >(), and Eigen::numext::real_ref().

Here is the call graph for this function:

pload< Packet2cf >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pload< Packet2cf >

(

const std::complex< float > *

from

)

{ EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>((const float*)from)); }

References EIGEN_DEBUG_ALIGNED_LOAD, and pload< Packet4f >().

Here is the call graph for this function:

pload< Packet2d >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pload< Packet2d >

(

const double *

from

)

{ EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_pd(from); }

References EIGEN_DEBUG_ALIGNED_LOAD.

Referenced by pbroadcast4< Packet2d >(), pgather< double, Packet2d >(), pload< Packet1cd >(), ploaddup< Packet2d >(), and ploadu< Packet2d >().

Here is the caller graph for this function:

pload< Packet2d >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pload< Packet2d >

(

const double *

from

)

{
  // FIXME: No intrinsic yet
  EIGEN_DEBUG_ALIGNED_LOAD
  Packet *vfrom;
  vfrom = (Packet *) from;
  return vfrom->v2d;
}

References EIGEN_DEBUG_ALIGNED_LOAD, and Eigen::internal::Packet::v2d.

pload< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pload< Packet4cf >

(

const std::complex< float > *

from

)

{ EIGEN_DEBUG_ALIGNED_LOAD return Packet4cf(pload<Packet8f>(&numext::real_ref(*from))); }

References EIGEN_DEBUG_ALIGNED_LOAD, pload< Packet8f >(), and Eigen::numext::real_ref().

Here is the call graph for this function:

pload< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pload< Packet4d >

(

const double *

from

)

{ EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_pd(from); }

References EIGEN_DEBUG_ALIGNED_LOAD.

Referenced by pload< Packet2cd >().

Here is the caller graph for this function:

pload< Packet4f >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pload< Packet4f >

(

const float *

from

)

{
  EIGEN_DEBUG_ALIGNED_LOAD
#ifdef __VSX__
  return vec_vsx_ld(0, from);
#else
  return vec_ld(0, from);
#endif
}

References EIGEN_DEBUG_ALIGNED_LOAD.

Referenced by pbroadcast4< Packet4f >(), pgather< float, Packet4f >(), pload< Packet2cf >(), ploaddup< Packet4f >(), ploadu< Packet4f >(), and pset1< Packet2cf >().

Here is the caller graph for this function:

pload< Packet4f >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pload< Packet4f >

(

const float *

from

)

{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_f32(from); }

References EIGEN_DEBUG_ALIGNED_LOAD.

pload< Packet4f >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pload< Packet4f >

(

const float *

from

)

{ EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_ps(from); }

References EIGEN_DEBUG_ALIGNED_LOAD.

pload< Packet4f >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pload< Packet4f >

(

const float *

from

)

{
  // FIXME: No intrinsic yet
  EIGEN_DEBUG_ALIGNED_LOAD
  Packet4f vfrom;
  vfrom.v4f[0] = vec_ld2f(&from[0]);
  vfrom.v4f[1] = vec_ld2f(&from[2]);
  return vfrom;
}

References EIGEN_DEBUG_ALIGNED_LOAD, and Eigen::internal::Packet4f::v4f.

pload< Packet4i >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pload< Packet4i >

(

const int *

from

)

{
  EIGEN_DEBUG_ALIGNED_LOAD
#ifdef __VSX__
  return vec_vsx_ld(0, from);
#else
  return vec_ld(0, from);
#endif
}

References EIGEN_DEBUG_ALIGNED_LOAD.

Referenced by pbroadcast4< Packet4i >(), pgather< int, Packet4i >(), ploaddup< Packet4i >(), and ploadu< Packet4i >().

Here is the caller graph for this function:

pload< Packet4i >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pload< Packet4i >

(

const int *

from

)

{ EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_si128(reinterpret_cast<const __m128i*>(from)); }

References EIGEN_DEBUG_ALIGNED_LOAD.

pload< Packet4i >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pload< Packet4i >

(

const int *

from

)

{
  // FIXME: No intrinsic yet
  EIGEN_DEBUG_ALIGNED_LOAD
  Packet *vfrom;
  vfrom = (Packet *) from;
  return vfrom->v4i;
}

References EIGEN_DEBUG_ALIGNED_LOAD, and Eigen::internal::Packet::v4i.

pload< Packet4i >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pload< Packet4i >

(

const int32_t *

from

)

{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_s32(from); }

References EIGEN_DEBUG_ALIGNED_LOAD.

pload< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pload< Packet8d >

(

const double *

from

)

                                                                 {
  EIGEN_DEBUG_ALIGNED_LOAD return _mm512_load_pd(from);
}

References EIGEN_DEBUG_ALIGNED_LOAD.

pload< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pload< Packet8f >

(

const float *

from

)

{ EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_ps(from); }

References EIGEN_DEBUG_ALIGNED_LOAD.

Referenced by pload< Packet4cf >().

Here is the caller graph for this function:

pload< Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::pload< Packet8i >

(

const int *

from

)

{ EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_si256(reinterpret_cast<const __m256i*>(from)); }

References EIGEN_DEBUG_ALIGNED_LOAD.

ploaddup()

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::ploaddup

(

const typename unpacket_traits< Packet >::type *

from

)

{ return *from; }

ploaddup< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::ploaddup< Packet16f >

(

const float *

from

)

                                                                     {
  Packet8f lane0 = _mm256_broadcast_ps((const __m128*)(const void*)from);
  // mimic an "inplace" permutation of the lower 128bits using a blend
  lane0 = _mm256_blend_ps(
      lane0, _mm256_castps128_ps256(_mm_permute_ps(
                 _mm256_castps256_ps128(lane0), _MM_SHUFFLE(1, 0, 1, 0))),
      15);
  // then we can perform a consistent permutation on the global register to get
  // everything in shape:
  lane0 = _mm256_permute_ps(lane0, _MM_SHUFFLE(3, 3, 2, 2));
 
  Packet8f lane1 = _mm256_broadcast_ps((const __m128*)(const void*)(from + 4));
  // mimic an "inplace" permutation of the lower 128bits using a blend
  lane1 = _mm256_blend_ps(
      lane1, _mm256_castps128_ps256(_mm_permute_ps(
                 _mm256_castps256_ps128(lane1), _MM_SHUFFLE(1, 0, 1, 0))),
      15);
  // then we can perform a consistent permutation on the global register to get
  // everything in shape:
  lane1 = _mm256_permute_ps(lane1, _MM_SHUFFLE(3, 3, 2, 2));
 
#ifdef EIGEN_VECTORIZE_AVX512DQ
  Packet16f res = _mm512_undefined_ps();
  return _mm512_insertf32x8(res, lane0, 0);
  return _mm512_insertf32x8(res, lane1, 1);
  return res;
#else
  Packet16f res = _mm512_undefined_ps();
  res = _mm512_insertf32x4(res, _mm256_extractf128_ps(lane0, 0), 0);
  res = _mm512_insertf32x4(res, _mm256_extractf128_ps(lane0, 1), 1);
  res = _mm512_insertf32x4(res, _mm256_extractf128_ps(lane1, 0), 2);
  res = _mm512_insertf32x4(res, _mm256_extractf128_ps(lane1, 1), 3);
  return res;
#endif
}

ploaddup< Packet1cd >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::ploaddup< Packet1cd >

(

const std::complex< double > *

from

)

{ return pset1<Packet1cd>(*from); }

References pset1< Packet1cd >().

Here is the call graph for this function:

ploaddup< Packet1cd >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::ploaddup< Packet1cd >

(

const std::complex< double > *

from

)

{  return pset1<Packet1cd>(*from); }

References pset1< Packet1cd >().

Here is the call graph for this function:

ploaddup< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::ploaddup< Packet2cd >

(

const std::complex< double > *

from

)

{ return pset1<Packet2cd>(*from); }

References pset1< Packet2cd >().

Here is the call graph for this function:

ploaddup< Packet2cf >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploaddup< Packet2cf >

(

const std::complex< float > *

from

)

{ return pset1<Packet2cf>(*from); }

References pset1< Packet2cf >().

Referenced by ploaddup< Packet4cf >().

Here is the call graph for this function:

Here is the caller graph for this function:

ploaddup< Packet2cf >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploaddup< Packet2cf >

(

const std::complex< float > *

from

)

{ return pset1<Packet2cf>(*from); }

References pset1< Packet2cf >().

Here is the call graph for this function:

ploaddup< Packet2cf >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploaddup< Packet2cf >

(

const std::complex< float > *

from

)

{ return pset1<Packet2cf>(*from); }

References pset1< Packet2cf >().

Here is the call graph for this function:

ploaddup< Packet2cf >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploaddup< Packet2cf >

(

const std::complex< float > *

from

)

{  return pset1<Packet2cf>(*from); }

References pset1< Packet2cf >().

Here is the call graph for this function:

ploaddup< Packet2d >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::ploaddup< Packet2d >

(

const double *

from

)

{ return pset1<Packet2d>(from[0]); }

References pset1< Packet2d >().

Here is the call graph for this function:

ploaddup< Packet2d >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::ploaddup< Packet2d >

(

const double *

from

)

{
  Packet2d p = pload<Packet2d>(from);
  return vec_perm(p, p, p16uc_PSET64_HI);
}

References p16uc_PSET64_HI, and pload< Packet2d >().

Here is the call graph for this function:

ploaddup< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::ploaddup< Packet4cf >

(

const std::complex< float > *

from

)

{
  // FIXME The following might be optimized using _mm256_movedup_pd
  Packet2cf a = ploaddup<Packet2cf>(from);
  Packet2cf b = ploaddup<Packet2cf>(from+1);
  return  Packet4cf(_mm256_insertf128_ps(_mm256_castps128_ps256(a.v), b.v, 1));
}

References ploaddup< Packet2cf >().

Here is the call graph for this function:

ploaddup< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::ploaddup< Packet4d >

(

const double *

from

)

{
  Packet4d tmp = _mm256_broadcast_pd((const __m128d*)(const void*)from);
  return  _mm256_permute_pd(tmp, 3<<2);
}

ploaddup< Packet4f >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploaddup< Packet4f >

(

const float *

from

)

{
  Packet4f p;
  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet4f>(from);
  else                                  p = ploadu<Packet4f>(from);
  return vec_perm(p, p, p16uc_DUPLICATE32_HI);
}

References p16uc_DUPLICATE32_HI, pload< Packet4f >(), and ploadu< Packet4f >().

Here is the call graph for this function:

ploaddup< Packet4f >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploaddup< Packet4f >

(

const float *

from

)

{
  float32x2_t lo, hi;
  lo = vld1_dup_f32(from);
  hi = vld1_dup_f32(from+1);
  return vcombine_f32(lo, hi);
}

ploaddup< Packet4f >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploaddup< Packet4f >

(

const float *

from

)

{
  return vec4f_swizzle1(_mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(from))), 0, 0, 1, 1);
}

References vec4f_swizzle1.

ploaddup< Packet4f >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploaddup< Packet4f >

(

const float *

from

)

{
  Packet4f p = pload<Packet4f>(from);
  p.v4f[1] = vec_splat(p.v4f[0], 1);
  p.v4f[0] = vec_splat(p.v4f[0], 0);
  return p;
}

References pload< Packet4f >(), and Eigen::internal::Packet4f::v4f.

Here is the call graph for this function:

ploaddup< Packet4i >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploaddup< Packet4i >

(

const int *

from

)

{
  Packet4i p;
  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet4i>(from);
  else                                  p = ploadu<Packet4i>(from);
  return vec_perm(p, p, p16uc_DUPLICATE32_HI);
}

References p16uc_DUPLICATE32_HI, pload< Packet4i >(), and ploadu< Packet4i >().

Here is the call graph for this function:

ploaddup< Packet4i >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploaddup< Packet4i >

(

const int *

from

)

{
  Packet4i tmp;
  tmp = _mm_loadl_epi64(reinterpret_cast<const __m128i*>(from));
  return vec4i_swizzle1(tmp, 0, 0, 1, 1);
}

References vec4i_swizzle1.

ploaddup< Packet4i >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploaddup< Packet4i >

(

const int *

from

)

{
  Packet4i p = pload<Packet4i>(from);
  return vec_perm(p, p, p16uc_DUPLICATE32_HI);
}

References p16uc_DUPLICATE32_HI, and pload< Packet4i >().

Here is the call graph for this function:

ploaddup< Packet4i >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploaddup< Packet4i >

(

const int32_t *

from

)

{
  int32x2_t lo, hi;
  lo = vld1_dup_s32(from);
  hi = vld1_dup_s32(from+1);
  return vcombine_s32(lo, hi);
}

ploaddup< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::ploaddup< Packet8d >

(

const double *

from

)

                                                                    {
  Packet4d lane0 = _mm256_broadcast_pd((const __m128d*)(const void*)from);
  lane0 = _mm256_permute_pd(lane0, 3 << 2);
 
  Packet4d lane1 = _mm256_broadcast_pd((const __m128d*)(const void*)(from + 2));
  lane1 = _mm256_permute_pd(lane1, 3 << 2);
 
  Packet8d res = _mm512_undefined_pd();
  res = _mm512_insertf64x4(res, lane0, 0);
  return _mm512_insertf64x4(res, lane1, 1);
}

ploaddup< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::ploaddup< Packet8f >

(

const float *

from

)

{
  // TODO try to find a way to avoid the need of a temporary register
//   Packet8f tmp  = _mm256_castps128_ps256(_mm_loadu_ps(from));
//   tmp = _mm256_insertf128_ps(tmp, _mm_movehl_ps(_mm256_castps256_ps128(tmp),_mm256_castps256_ps128(tmp)), 1);
//   return _mm256_unpacklo_ps(tmp,tmp);
  
  // _mm256_insertf128_ps is very slow on Haswell, thus:
  Packet8f tmp = _mm256_broadcast_ps((const __m128*)(const void*)from);
  // mimic an "inplace" permutation of the lower 128bits using a blend
  tmp = _mm256_blend_ps(tmp,_mm256_castps128_ps256(_mm_permute_ps( _mm256_castps256_ps128(tmp), _MM_SHUFFLE(1,0,1,0))), 15);
  // then we can perform a consistent permutation on the global register to get everything in shape:
  return  _mm256_permute_ps(tmp, _MM_SHUFFLE(3,3,2,2));
}

ploadquad()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::ploadquad ( const typename unpacket_traits< Packet >::type *  from )

inline

{ return pload1<Packet>(from); }

ploadquad< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::ploadquad< Packet16f >

(

const float *

from

)

                                                                      {
  Packet16f tmp = _mm512_undefined_ps();
  tmp = _mm512_insertf32x4(tmp, _mm_load_ps1(from), 0);
  tmp = _mm512_insertf32x4(tmp, _mm_load_ps1(from + 1), 1);
  tmp = _mm512_insertf32x4(tmp, _mm_load_ps1(from + 2), 2);
  tmp = _mm512_insertf32x4(tmp, _mm_load_ps1(from + 3), 3);
  return tmp;
}

ploadquad< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::ploadquad< Packet8d >

(

const double *

from

)

                                                                     {
  Packet8d tmp = _mm512_undefined_pd();
  Packet2d tmp0 = _mm_load_pd1(from);
  Packet2d tmp1 = _mm_load_pd1(from + 1);
  Packet4d lane0 = _mm256_broadcastsd_pd(tmp0);
  Packet4d lane1 = _mm256_broadcastsd_pd(tmp1);
  tmp = _mm512_insertf64x4(tmp, lane0, 0);
  return _mm512_insertf64x4(tmp, lane1, 1);
}

ploadquad< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::ploadquad< Packet8f >

(

const float *

from

)

{
  Packet8f tmp = _mm256_castps128_ps256(_mm_broadcast_ss(from));
  return _mm256_insertf128_ps(tmp, _mm_broadcast_ss(from+1), 1);
}

ploadt()

template<typename Packet , int Alignment>

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet Eigen::internal::ploadt

(

const typename unpacket_traits< Packet >::type *

from

)

{
  if(Alignment >= unpacket_traits<Packet>::alignment)
    return pload<Packet>(from);
  else
    return ploadu<Packet>(from);
}

ploadt_ro()

template<typename Packet , int LoadMode>

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet Eigen::internal::ploadt_ro

(

const typename unpacket_traits< Packet >::type *

from

)

{
  return ploadt<Packet, LoadMode>(from);
}

ploadu()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::ploadu ( const typename unpacket_traits< Packet >::type *  from )

inline

{ return *from; }

ploadu< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::ploadu< Packet16f >

(

const float *

from

)

                                                                   {
  EIGEN_DEBUG_UNALIGNED_LOAD return _mm512_loadu_ps(from);
}

References EIGEN_DEBUG_UNALIGNED_LOAD.

ploadu< Packet16i >()

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::ploadu< Packet16i >

(

const int *

from

)

                                                                 {
  EIGEN_DEBUG_UNALIGNED_LOAD return _mm512_loadu_si512(
      reinterpret_cast<const __m512i*>(from));
}

References EIGEN_DEBUG_UNALIGNED_LOAD.

ploadu< Packet1cd >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::ploadu< Packet1cd >

(

const std::complex< double > *

from

)

{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu<Packet2d>((const double*)from)); }

References EIGEN_DEBUG_UNALIGNED_LOAD, and ploadu< Packet2d >().

Referenced by pset1< Packet1cd >().

Here is the call graph for this function:

Here is the caller graph for this function:

ploadu< Packet1cd >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::ploadu< Packet1cd >

(

const std::complex< double > *

from

)

{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu<Packet2d>((const double*)from)); }

References EIGEN_DEBUG_UNALIGNED_LOAD, and ploadu< Packet2d >().

Here is the call graph for this function:

ploadu< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::ploadu< Packet2cd >

(

const std::complex< double > *

from

)

{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cd(ploadu<Packet4d>((const double*)from)); }

References EIGEN_DEBUG_UNALIGNED_LOAD, and ploadu< Packet4d >().

Here is the call graph for this function:

ploadu< Packet2cf >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploadu< Packet2cf >

(

const std::complex< float > *

from

)

{ return Packet2cf(ploadu<Packet4f>((const float*) from)); }

References ploadu< Packet4f >().

Here is the call graph for this function:

ploadu< Packet2cf >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploadu< Packet2cf >

(

const std::complex< float > *

from

)

{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>((const float*)from)); }

References EIGEN_DEBUG_UNALIGNED_LOAD, and ploadu< Packet4f >().

Here is the call graph for this function:

ploadu< Packet2cf >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploadu< Packet2cf >

(

const std::complex< float > *

from

)

{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>(&numext::real_ref(*from))); }

References EIGEN_DEBUG_UNALIGNED_LOAD, ploadu< Packet4f >(), and Eigen::numext::real_ref().

Here is the call graph for this function:

ploadu< Packet2cf >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploadu< Packet2cf >

(

const std::complex< float > *

from

)

{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>((const float*)from)); }

References EIGEN_DEBUG_UNALIGNED_LOAD, and ploadu< Packet4f >().

Here is the call graph for this function:

ploadu< Packet2d >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::ploadu< Packet2d >

(

const double *

from

)

{
  EIGEN_DEBUG_UNALIGNED_LOAD
  return _mm_loadu_pd(from);
}

References EIGEN_DEBUG_UNALIGNED_LOAD.

Referenced by ploadu< Packet1cd >().

Here is the caller graph for this function:

ploadu< Packet2d >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::ploadu< Packet2d >

(

const double *

from

)

{ return pload<Packet2d>(from); }

References pload< Packet2d >().

Here is the call graph for this function:

ploadu< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::ploadu< Packet4cf >

(

const std::complex< float > *

from

)

{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet4cf(ploadu<Packet8f>(&numext::real_ref(*from))); }

References EIGEN_DEBUG_UNALIGNED_LOAD, ploadu< Packet8f >(), and Eigen::numext::real_ref().

Here is the call graph for this function:

ploadu< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::ploadu< Packet4d >

(

const double *

from

)

{ EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_pd(from); }

References EIGEN_DEBUG_UNALIGNED_LOAD.

Referenced by ploadu< Packet2cd >().

Here is the caller graph for this function:

ploadu< Packet4f >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploadu< Packet4f >

(

const float *

from

)

{
  EIGEN_DEBUG_UNALIGNED_LOAD
  return (Packet4f) vec_vsx_ld((long)from & 15, (const float*) _EIGEN_ALIGNED_PTR(from));
}

References _EIGEN_ALIGNED_PTR, and EIGEN_DEBUG_UNALIGNED_LOAD.

Referenced by ploaddup< Packet4f >(), ploadu< Packet2cf >(), and pset1< Packet2cf >().

Here is the caller graph for this function:

ploadu< Packet4f >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploadu< Packet4f >

(

const float *

from

)

{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_f32(from); }

References EIGEN_DEBUG_UNALIGNED_LOAD.

ploadu< Packet4f >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploadu< Packet4f >

(

const float *

from

)

{
  EIGEN_DEBUG_UNALIGNED_LOAD
  return _mm_loadu_ps(from);
}

References EIGEN_DEBUG_UNALIGNED_LOAD.

ploadu< Packet4f >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploadu< Packet4f >

(

const float *

from

)

{ return pload<Packet4f>(from); }

References pload< Packet4f >().

Here is the call graph for this function:

ploadu< Packet4i >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploadu< Packet4i >

(

const int *

from

)

{
  EIGEN_DEBUG_UNALIGNED_LOAD
  return (Packet4i) vec_vsx_ld((long)from & 15, (const int*) _EIGEN_ALIGNED_PTR(from));
}

References _EIGEN_ALIGNED_PTR, and EIGEN_DEBUG_UNALIGNED_LOAD.

Referenced by ploaddup< Packet4i >().

Here is the caller graph for this function:

ploadu< Packet4i >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploadu< Packet4i >

(

const int *

from

)

{
  EIGEN_DEBUG_UNALIGNED_LOAD
  return _mm_loadu_si128(reinterpret_cast<const __m128i*>(from));
}

References EIGEN_DEBUG_UNALIGNED_LOAD.

ploadu< Packet4i >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploadu< Packet4i >

(

const int *

from

)

{ return pload<Packet4i>(from); }

References pload< Packet4i >().

Here is the call graph for this function:

ploadu< Packet4i >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploadu< Packet4i >

(

const int32_t *

from

)

{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_s32(from); }

References EIGEN_DEBUG_UNALIGNED_LOAD.

ploadu< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::ploadu< Packet8d >

(

const double *

from

)

                                                                  {
  EIGEN_DEBUG_UNALIGNED_LOAD return _mm512_loadu_pd(from);
}

References EIGEN_DEBUG_UNALIGNED_LOAD.

ploadu< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::ploadu< Packet8f >

(

const float *

from

)

{ EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_ps(from); }

References EIGEN_DEBUG_UNALIGNED_LOAD.

Referenced by ploadu< Packet4cf >().

Here is the caller graph for this function:

ploadu< Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::ploadu< Packet8i >

(

const int *

from

)

{ EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(from)); }

References EIGEN_DEBUG_UNALIGNED_LOAD.

plog()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::plog

(

const Packet &

a

)

{ using std::log; return log(a); }

References log().

Referenced by Eigen::internal::scalar_log_op< Scalar >::packetOp().

Here is the call graph for this function:

Here is the caller graph for this function:

plog10()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::plog10

(

const Packet &

a

)

{ using std::log10; return log10(a); }

References log10().

Here is the call graph for this function:

plog1p()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::plog1p

(

const Packet &

a

)

{ return numext::log1p(a); }

plog< Packet4f >() [1/2]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::plog< Packet4f >

(

const Packet4f &

_x

)

{
  Packet4f x = _x;
 
  Packet4i emm0;
 
  /* isvalid_mask is 0 if x < 0 or x is NaN. */
  Packet4ui isvalid_mask = reinterpret_cast<Packet4ui>(vec_cmpge(x, p4f_ZERO));
  Packet4ui iszero_mask = reinterpret_cast<Packet4ui>(vec_cmpeq(x, p4f_ZERO));
 
  x = pmax(x, p4f_min_norm_pos);  /* cut off denormalized stuff */
  emm0 = vec_sr(reinterpret_cast<Packet4i>(x),
                reinterpret_cast<Packet4ui>(p4i_23));
 
  /* keep only the fractional part */
  x = pand(x, p4f_inv_mant_mask);
  x = por(x, p4f_half);
 
  emm0 = psub(emm0, p4i_0x7f);
  Packet4f e = padd(vec_ctf(emm0, 0), p4f_1);
 
  /* part2:
     if( x < SQRTHF ) {
       e -= 1;
       x = x + x - 1.0;
     } else { x = x - 1.0; }
  */
  Packet4f mask = reinterpret_cast<Packet4f>(vec_cmplt(x, p4f_cephes_SQRTHF));
  Packet4f tmp = pand(x, mask);
  x = psub(x, p4f_1);
  e = psub(e, pand(p4f_1, mask));
  x = padd(x, tmp);
 
  Packet4f x2 = pmul(x,x);
  Packet4f x3 = pmul(x2,x);
 
  Packet4f y, y1, y2;
  y  = pmadd(p4f_cephes_log_p0, x, p4f_cephes_log_p1);
  y1 = pmadd(p4f_cephes_log_p3, x, p4f_cephes_log_p4);
  y2 = pmadd(p4f_cephes_log_p6, x, p4f_cephes_log_p7);
  y  = pmadd(y , x, p4f_cephes_log_p2);
  y1 = pmadd(y1, x, p4f_cephes_log_p5);
  y2 = pmadd(y2, x, p4f_cephes_log_p8);
  y = pmadd(y, x3, y1);
  y = pmadd(y, x3, y2);
  y = pmul(y, x3);
 
  y1 = pmul(e, p4f_cephes_log_q1);
  tmp = pmul(x2, p4f_half);
  y = padd(y, y1);
  x = psub(x, tmp);
  y2 = pmul(e, p4f_cephes_log_q2);
  x = padd(x, y);
  x = padd(x, y2);
  // negative arg will be NAN, 0 will be -INF
  x = vec_sel(x, p4f_minus_inf, iszero_mask);
  x = vec_sel(p4f_minus_nan, x, isvalid_mask);
  return x;
}

References padd(), pand(), pmadd(), pmax(), pmul(), por(), psub(), and y.

Here is the call graph for this function:

plog< Packet4f >() [2/2]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::plog< Packet4f >

(

const Packet4f &

_x

)

{
  Packet4f x = _x;
  _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f);
  _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
  _EIGEN_DECLARE_CONST_Packet4i(0x7f, 0x7f);
 
  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(inv_mant_mask, ~0x7f800000);
 
  /* the smallest non denormalized float number */
  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(min_norm_pos,  0x00800000);
  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(minus_inf,     0xff800000);//-1.f/0.f);
 
  /* natural logarithm computed for 4 simultaneous float
    return NaN for x <= 0
  */
  _EIGEN_DECLARE_CONST_Packet4f(cephes_SQRTHF, 0.707106781186547524f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p0, 7.0376836292E-2f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p1, - 1.1514610310E-1f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p2, 1.1676998740E-1f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p3, - 1.2420140846E-1f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p4, + 1.4249322787E-1f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p5, - 1.6668057665E-1f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p6, + 2.0000714765E-1f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p7, - 2.4999993993E-1f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p8, + 3.3333331174E-1f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_q1, -2.12194440e-4f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_q2, 0.693359375f);
 
 
  Packet4i emm0;
 
  Packet4f invalid_mask = _mm_cmpnge_ps(x, _mm_setzero_ps()); // not greater equal is true if x is NaN
  Packet4f iszero_mask = _mm_cmpeq_ps(x, _mm_setzero_ps());
 
  x = pmax(x, p4f_min_norm_pos);  /* cut off denormalized stuff */
  emm0 = _mm_srli_epi32(_mm_castps_si128(x), 23);
 
  /* keep only the fractional part */
  x = _mm_and_ps(x, p4f_inv_mant_mask);
  x = _mm_or_ps(x, p4f_half);
 
  emm0 = _mm_sub_epi32(emm0, p4i_0x7f);
  Packet4f e = padd(Packet4f(_mm_cvtepi32_ps(emm0)), p4f_1);
 
  /* part2:
     if( x < SQRTHF ) {
       e -= 1;
       x = x + x - 1.0;
     } else { x = x - 1.0; }
  */
  Packet4f mask = _mm_cmplt_ps(x, p4f_cephes_SQRTHF);
  Packet4f tmp = pand(x, mask);
  x = psub(x, p4f_1);
  e = psub(e, pand(p4f_1, mask));
  x = padd(x, tmp);
 
  Packet4f x2 = pmul(x,x);
  Packet4f x3 = pmul(x2,x);
 
  Packet4f y, y1, y2;
  y  = pmadd(p4f_cephes_log_p0, x, p4f_cephes_log_p1);
  y1 = pmadd(p4f_cephes_log_p3, x, p4f_cephes_log_p4);
  y2 = pmadd(p4f_cephes_log_p6, x, p4f_cephes_log_p7);
  y  = pmadd(y , x, p4f_cephes_log_p2);
  y1 = pmadd(y1, x, p4f_cephes_log_p5);
  y2 = pmadd(y2, x, p4f_cephes_log_p8);
  y = pmadd(y, x3, y1);
  y = pmadd(y, x3, y2);
  y = pmul(y, x3);
 
  y1 = pmul(e, p4f_cephes_log_q1);
  tmp = pmul(x2, p4f_half);
  y = padd(y, y1);
  x = psub(x, tmp);
  y2 = pmul(e, p4f_cephes_log_q2);
  x = padd(x, y);
  x = padd(x, y2);
  // negative arg will be NAN, 0 will be -INF
  return _mm_or_ps(_mm_andnot_ps(iszero_mask, _mm_or_ps(x, invalid_mask)),
                   _mm_and_ps(iszero_mask, p4f_minus_inf));
}

References _EIGEN_DECLARE_CONST_Packet4f, _EIGEN_DECLARE_CONST_Packet4f_FROM_INT, _EIGEN_DECLARE_CONST_Packet4i, padd(), pand(), pmadd(), pmax(), pmul(), psub(), and y.

Here is the call graph for this function:

plog< Packet8f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f Eigen::internal::plog< Packet8f >

(

const Packet8f &

_x

)

                                   {
  Packet8f x = _x;
  _EIGEN_DECLARE_CONST_Packet8f(1, 1.0f);
  _EIGEN_DECLARE_CONST_Packet8f(half, 0.5f);
  _EIGEN_DECLARE_CONST_Packet8f(126f, 126.0f);
 
  _EIGEN_DECLARE_CONST_Packet8f_FROM_INT(inv_mant_mask, ~0x7f800000);
 
  // The smallest non denormalized float number.
  _EIGEN_DECLARE_CONST_Packet8f_FROM_INT(min_norm_pos, 0x00800000);
  _EIGEN_DECLARE_CONST_Packet8f_FROM_INT(minus_inf, 0xff800000);
 
  // Polynomial coefficients.
  _EIGEN_DECLARE_CONST_Packet8f(cephes_SQRTHF, 0.707106781186547524f);
  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p0, 7.0376836292E-2f);
  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p1, -1.1514610310E-1f);
  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p2, 1.1676998740E-1f);
  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p3, -1.2420140846E-1f);
  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p4, +1.4249322787E-1f);
  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p5, -1.6668057665E-1f);
  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p6, +2.0000714765E-1f);
  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p7, -2.4999993993E-1f);
  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p8, +3.3333331174E-1f);
  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_q1, -2.12194440e-4f);
  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_q2, 0.693359375f);
 
  Packet8f invalid_mask = _mm256_cmp_ps(x, _mm256_setzero_ps(), _CMP_NGE_UQ); // not greater equal is true if x is NaN
  Packet8f iszero_mask = _mm256_cmp_ps(x, _mm256_setzero_ps(), _CMP_EQ_OQ);
 
  // Truncate input values to the minimum positive normal.
  x = pmax(x, p8f_min_norm_pos);
 
  Packet8f emm0 = pshiftright(x,23);
  Packet8f e = _mm256_sub_ps(emm0, p8f_126f);
 
  // Set the exponents to -1, i.e. x are in the range [0.5,1).
  x = _mm256_and_ps(x, p8f_inv_mant_mask);
  x = _mm256_or_ps(x, p8f_half);
 
  // part2: Shift the inputs from the range [0.5,1) to [sqrt(1/2),sqrt(2))
  // and shift by -1. The values are then centered around 0, which improves
  // the stability of the polynomial evaluation.
  //   if( x < SQRTHF ) {
  //     e -= 1;
  //     x = x + x - 1.0;
  //   } else { x = x - 1.0; }
  Packet8f mask = _mm256_cmp_ps(x, p8f_cephes_SQRTHF, _CMP_LT_OQ);
  Packet8f tmp = _mm256_and_ps(x, mask);
  x = psub(x, p8f_1);
  e = psub(e, _mm256_and_ps(p8f_1, mask));
  x = padd(x, tmp);
 
  Packet8f x2 = pmul(x, x);
  Packet8f x3 = pmul(x2, x);
 
  // Evaluate the polynomial approximant of degree 8 in three parts, probably
  // to improve instruction-level parallelism.
  Packet8f y, y1, y2;
  y = pmadd(p8f_cephes_log_p0, x, p8f_cephes_log_p1);
  y1 = pmadd(p8f_cephes_log_p3, x, p8f_cephes_log_p4);
  y2 = pmadd(p8f_cephes_log_p6, x, p8f_cephes_log_p7);
  y = pmadd(y, x, p8f_cephes_log_p2);
  y1 = pmadd(y1, x, p8f_cephes_log_p5);
  y2 = pmadd(y2, x, p8f_cephes_log_p8);
  y = pmadd(y, x3, y1);
  y = pmadd(y, x3, y2);
  y = pmul(y, x3);
 
  // Add the logarithm of the exponent back to the result of the interpolation.
  y1 = pmul(e, p8f_cephes_log_q1);
  tmp = pmul(x2, p8f_half);
  y = padd(y, y1);
  x = psub(x, tmp);
  y2 = pmul(e, p8f_cephes_log_q2);
  x = padd(x, y);
  x = padd(x, y2);
 
  // Filter out invalid inputs, i.e. negative arg will be NAN, 0 will be -INF.
  return _mm256_or_ps(
      _mm256_andnot_ps(iszero_mask, _mm256_or_ps(x, invalid_mask)),
      _mm256_and_ps(iszero_mask, p8f_minus_inf));
}

References _EIGEN_DECLARE_CONST_Packet8f, _EIGEN_DECLARE_CONST_Packet8f_FROM_INT, padd(), pmadd(), pmax(), pmul(), pshiftright(), psub(), and y.

Here is the call graph for this function:

plset()

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::plset

(

const typename unpacket_traits< Packet >::type &

a

)

{ return a; }

plset< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::plset< Packet16f >

(

const float &

a

)

                                                               {
  return _mm512_add_ps(
      _mm512_set1_ps(a),
      _mm512_set_ps(15.0f, 14.0f, 13.0f, 12.0f, 11.0f, 10.0f, 9.0f, 8.0f, 7.0f, 6.0f, 5.0f,
                    4.0f, 3.0f, 2.0f, 1.0f, 0.0f));
}

plset< Packet2d >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::plset< Packet2d >

(

const double &

a

)

{ return _mm_add_pd(pset1<Packet2d>(a),_mm_set_pd(1,0)); }

References pset1< Packet2d >().

Here is the call graph for this function:

plset< Packet2d >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::plset< Packet2d >

(

const double &

a

)

{ return padd<Packet2d>(pset1<Packet2d>(a), p2d_COUNTDOWN); }

References p2d_COUNTDOWN, padd< Packet2d >(), and pset1< Packet2d >().

Here is the call graph for this function:

plset< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::plset< Packet4d >

(

const double &

a

)

{ return _mm256_add_pd(_mm256_set1_pd(a), _mm256_set_pd(3.0,2.0,1.0,0.0)); }

plset< Packet4f >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::plset< Packet4f >

(

const float &

a

)

{ return pset1<Packet4f>(a) + p4f_COUNTDOWN; }

References p4f_COUNTDOWN, and pset1< Packet4f >().

Here is the call graph for this function:

plset< Packet4f >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::plset< Packet4f >

(

const float &

a

)

{
  const float f[] = {0, 1, 2, 3};
  Packet4f countdown = vld1q_f32(f);
  return vaddq_f32(pset1<Packet4f>(a), countdown);
}

References pset1< Packet4f >().

Here is the call graph for this function:

plset< Packet4f >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::plset< Packet4f >

(

const float &

a

)

{ return _mm_add_ps(pset1<Packet4f>(a), _mm_set_ps(3,2,1,0)); }

References pset1< Packet4f >().

Here is the call graph for this function:

plset< Packet4f >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::plset< Packet4f >

(

const float &

a

)

{ return padd<Packet4f>(pset1<Packet4f>(a), p4f_COUNTDOWN); }

References p4f_COUNTDOWN, padd< Packet4f >(), and pset1< Packet4f >().

Here is the call graph for this function:

plset< Packet4i >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::plset< Packet4i >

(

const int &

a

)

{ return pset1<Packet4i>(a) + p4i_COUNTDOWN; }

References p4i_COUNTDOWN, and pset1< Packet4i >().

Here is the call graph for this function:

plset< Packet4i >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::plset< Packet4i >

(

const int &

a

)

{ return _mm_add_epi32(pset1<Packet4i>(a),_mm_set_epi32(3,2,1,0)); }

References pset1< Packet4i >().

Here is the call graph for this function:

plset< Packet4i >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::plset< Packet4i >

(

const int &

a

)

{ return padd<Packet4i>(pset1<Packet4i>(a), p4i_COUNTDOWN); }

References p4i_COUNTDOWN, padd< Packet4i >(), and pset1< Packet4i >().

Here is the call graph for this function:

plset< Packet4i >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::plset< Packet4i >

(

const int32_t &

a

)

{
  const int32_t i[] = {0, 1, 2, 3};
  Packet4i countdown = vld1q_s32(i);
  return vaddq_s32(pset1<Packet4i>(a), countdown);
}

References pset1< Packet4i >().

Here is the call graph for this function:

plset< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::plset< Packet8d >

(

const double &

a

)

                                                              {
  return _mm512_add_pd(_mm512_set1_pd(a),
                       _mm512_set_pd(7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 0.0));
}

plset< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::plset< Packet8f >

(

const float &

a

)

{ return _mm256_add_ps(_mm256_set1_ps(a), _mm256_set_ps(7.0,6.0,5.0,4.0,3.0,2.0,1.0,0.0)); }

pmadd() [1/9]

template<typename Packet >

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

inline

{ return padd(pmul(a, b),c); }

References padd(), and pmul().

Here is the call graph for this function:

pmadd() [2/9]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmadd	(	const Packet2d &	a,
		const Packet2d &	b,
		const Packet2d &	c
	)

{ return vec_madd(a, b, c); }

pmadd() [3/9]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmadd	(	const Packet4f &	a,
		const Packet4f &	b,
		const Packet4f &	c
	)

{ return vec_madd(a,b,c); }

Referenced by Eigen::internal::gebp_traits< _LhsScalar, _RhsScalar, _ConjLhs, _ConjRhs >::acc(), Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs >::acc(), Eigen::internal::gebp_traits< _LhsScalar, _RhsScalar, _ConjLhs, _ConjRhs >::acc(), generic_fast_tanh_float(), Eigen::internal::gebp_traits< std::complex< RealScalar >, RealScalar, _ConjLhs, false >::madd_impl(), Eigen::internal::gebp_traits< RealScalar, std::complex< RealScalar >, false, _ConjRhs >::madd_impl(), pcos< Packet4f >(), pexp< Packet2d >(), pexp< Packet4d >(), pexp< Packet4f >(), pexp< Packet8f >(), plog< Packet4f >(), plog< Packet8f >(), Eigen::internal::conj_helper< Scalar, Scalar, false, false >::pmadd(), psin< Packet4f >(), psin< Packet8f >(), Eigen::internal::etor_product_packet_impl< RowMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode >::run(), Eigen::internal::etor_product_packet_impl< ColMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode >::run(), Eigen::internal::etor_product_packet_impl< RowMajor, Dynamic, Lhs, Rhs, Packet, LoadMode >::run(), and Eigen::internal::etor_product_packet_impl< ColMajor, Dynamic, Lhs, Rhs, Packet, LoadMode >::run().

Here is the caller graph for this function:

pmadd() [4/9]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmadd	(	const Packet4f &	a,
		const Packet4f &	b,
		const Packet4f &	c
	)

                                                                                                       {
#if EIGEN_COMP_CLANG && EIGEN_ARCH_ARM
  // Clang/ARM will replace VMLA by VMUL+VADD at least for some values of -mcpu,
  // at least -mcpu=cortex-a8 and -mcpu=cortex-a7. Since the former is the default on
  // -march=armv7-a, that is a very common case.
  // See e.g. this thread:
  //     http://lists.llvm.org/pipermail/llvm-dev/2013-December/068806.html
  // Filed LLVM bug:
  //     https://llvm.org/bugs/show_bug.cgi?id=27219
  Packet4f r = c;
  asm volatile(
    "vmla.f32 %q[r], %q[a], %q[b]"
    : [r] "+w" (r)
    : [a] "w" (a),
      [b] "w" (b)
    : );
  return r;
#else
  return vmlaq_f32(c,a,b);
#endif
}

pmadd() [5/9]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmadd	(	const Packet4f &	a,
		const Packet4f &	b,
		const Packet4f &	c
	)

{
  Packet4f res;
  res.v4f[0] = vec_madd(a.v4f[0], b.v4f[0], c.v4f[0]);
  res.v4f[1] = vec_madd(a.v4f[1], b.v4f[1], c.v4f[1]);
  return res;
}

References Eigen::internal::Packet4f::v4f.

pmadd() [6/9]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmadd	(	const Packet4i &	a,
		const Packet4i &	b,
		const Packet4i &	c
	)

{ return a*b + c; }

pmadd() [7/9]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmadd	(	const Packet4i &	a,
		const Packet4i &	b,
		const Packet4i &	c
	)

{ return vmlaq_s32(c,a,b); }

pmadd() [8/9]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmadd	(	const Packet4i &	a,
		const Packet4i &	b,
		const Packet4i &	c
	)

{ return padd(pmul(a,b), c); }

References padd(), and pmul().

Here is the call graph for this function:

pmadd() [9/9]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmadd	(	const Packet4i &	a,
		const Packet4i &	b,
		const Packet4i &	c
	)

{ return padd<Packet4i>(pmul<Packet4i>(a, b), c); }

References padd< Packet4i >(), and pmul< Packet4i >().

Here is the call graph for this function:

pmax()

template<typename Packet >

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

inline

                         { return numext::maxi(a, b); }

References Eigen::numext::maxi().

Referenced by generic_fast_tanh_float(), Eigen::internal::scalar_max_op< LhsScalar, RhsScalar >::packetOp(), pexp< Packet2d >(), pexp< Packet4d >(), pexp< Packet4f >(), pexp< Packet8f >(), plog< Packet4f >(), plog< Packet8f >(), and pmax< Packet4f >().

Here is the call graph for this function:

Here is the caller graph for this function:

pmax< Packet16f >()

template<>

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

                                                                  {
  return _mm512_max_ps(a, b);
}

pmax< Packet2d >() [1/2]

template<>

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

{ return _mm_max_pd(a,b); }

Referenced by predux_max< Packet2d >(), and predux_max< Packet4f >().

Here is the caller graph for this function:

pmax< Packet2d >() [2/2]

template<>

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

{ return vec_max(a, b); }

pmax< Packet4d >()

template<>

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

{ return _mm256_max_pd(a,b); }

pmax< Packet4f >() [1/4]

template<>

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

{
  #ifdef __VSX__
  Packet4f ret;
  __asm__ ("xvcmpgtsp %x0,%x2,%x1\n\txxsel %x0,%x1,%x2,%x0" : "=&wa" (ret) : "wa" (a), "wa" (b));
  return ret;
  #else
  return vec_max(a, b);
  #endif
}

pmax< Packet4f >() [2/4]

template<>

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

{ return vmaxq_f32(a,b); }

pmax< Packet4f >() [3/4]

template<>

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

{ return _mm_max_ps(a,b); }

pmax< Packet4f >() [4/4]

template<>

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

{
  Packet4f res;
  res.v4f[0] = pmax(a.v4f[0], b.v4f[0]);
  res.v4f[1] = pmax(a.v4f[1], b.v4f[1]);
  return res;
}

References pmax(), and Eigen::internal::Packet4f::v4f.

Here is the call graph for this function:

pmax< Packet4i >() [1/4]

template<>

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

{ return vec_max(a, b); }

Referenced by predux_max< Packet4i >().

Here is the caller graph for this function:

pmax< Packet4i >() [2/4]

template<>

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

{ return vmaxq_s32(a,b); }

pmax< Packet4i >() [3/4]

template<>

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

{
#ifdef EIGEN_VECTORIZE_SSE4_1
  return _mm_max_epi32(a,b);
#else
  // after some bench, this version *is* faster than a scalar implementation
  Packet4i mask = _mm_cmpgt_epi32(a,b);
  return _mm_or_si128(_mm_and_si128(mask,a),_mm_andnot_si128(mask,b));
#endif
}

pmax< Packet4i >() [4/4]

template<>

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

{ return vec_max(a, b); }

pmax< Packet8d >()

template<>

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

                                                               {
  return _mm512_max_pd(a, b);
}

pmax< Packet8f >()

template<>

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

{ return _mm256_max_ps(a,b); }

pmin()

template<typename Packet >

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

inline

                         { return numext::mini(a, b); }

References Eigen::numext::mini().

Referenced by generic_fast_tanh_float(), Eigen::internal::scalar_min_op< LhsScalar, RhsScalar >::packetOp(), pexp< Packet2d >(), pexp< Packet4d >(), pexp< Packet4f >(), pexp< Packet8f >(), and pmin< Packet4f >().

Here is the call graph for this function:

Here is the caller graph for this function:

pmin< Packet16f >()

template<>

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

                                                                  {
  return _mm512_min_ps(a, b);
}

pmin< Packet2d >() [1/2]

template<>

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

{ return _mm_min_pd(a,b); }

Referenced by predux_min< Packet2d >(), and predux_min< Packet4f >().

Here is the caller graph for this function:

pmin< Packet2d >() [2/2]

template<>

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

{ return vec_min(a, b); }

pmin< Packet4d >()

template<>

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

{ return _mm256_min_pd(a,b); }

pmin< Packet4f >() [1/4]

template<>

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

{
  #ifdef __VSX__
  Packet4f ret;
  __asm__ ("xvcmpgesp %x0,%x1,%x2\n\txxsel %x0,%x1,%x2,%x0" : "=&wa" (ret) : "wa" (a), "wa" (b));
  return ret;
  #else
  return vec_min(a, b);
  #endif
}

pmin< Packet4f >() [2/4]

template<>

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

{ return vminq_f32(a,b); }

pmin< Packet4f >() [3/4]

template<>

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

{ return _mm_min_ps(a,b); }

pmin< Packet4f >() [4/4]

template<>

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

{
  Packet4f res;
  res.v4f[0] = pmin(a.v4f[0], b.v4f[0]);
  res.v4f[1] = pmin(a.v4f[1], b.v4f[1]);
  return res;
}

References pmin(), and Eigen::internal::Packet4f::v4f.

Here is the call graph for this function:

pmin< Packet4i >() [1/4]

template<>

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

{ return vec_min(a, b); }

Referenced by predux_min< Packet4i >().

Here is the caller graph for this function:

pmin< Packet4i >() [2/4]

template<>

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

{ return vminq_s32(a,b); }

pmin< Packet4i >() [3/4]

template<>

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

{
#ifdef EIGEN_VECTORIZE_SSE4_1
  return _mm_min_epi32(a,b);
#else
  // after some bench, this version *is* faster than a scalar implementation
  Packet4i mask = _mm_cmplt_epi32(a,b);
  return _mm_or_si128(_mm_and_si128(mask,a),_mm_andnot_si128(mask,b));
#endif
}

pmin< Packet4i >() [4/4]

template<>

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

{ return vec_min(a, b); }

pmin< Packet8d >()

template<>

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

                                                               {
  return _mm512_min_pd(a, b);
}

pmin< Packet8f >()

template<>

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

{ return _mm256_min_ps(a,b); }

pmul() [1/3]

template<typename Packet >

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

inline

                         { return a*b; }

Referenced by Eigen::internal::mul_assign_op< DstScalar, SrcScalar >::assignPacket(), generic_fast_tanh_float(), Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs >::madd(), Eigen::internal::gebp_traits< std::complex< RealScalar >, RealScalar, _ConjLhs, false >::madd_impl(), Eigen::internal::gebp_traits< RealScalar, std::complex< RealScalar >, false, _ConjRhs >::madd_impl(), Eigen::internal::scalar_abs2_op< Scalar >::packetOp(), Eigen::internal::scalar_cube_op< Scalar >::packetOp(), Eigen::internal::scalar_product_op< LhsScalar, RhsScalar >::packetOp(), Eigen::internal::linspaced_op_impl< Scalar, Packet, false >::packetOp(), pcos< Packet4f >(), pdiv< Packet2cd >(), pdiv< Packet4cf >(), pexp< Packet2d >(), pexp< Packet4d >(), pexp< Packet4f >(), pexp< Packet8f >(), plog< Packet4f >(), plog< Packet8f >(), pmadd(), pmadd(), Eigen::internal::conj_helper< Packet1cd, Packet1cd, false, true >::pmul(), Eigen::internal::conj_helper< Packet1cd, Packet1cd, true, false >::pmul(), Eigen::internal::conj_helper< Packet1cd, Packet1cd, true, true >::pmul(), Eigen::internal::conj_helper< Packet2cd, Packet2cd, false, true >::pmul(), Eigen::internal::conj_helper< Packet2cd, Packet2cd, true, false >::pmul(), Eigen::internal::conj_helper< Packet2cd, Packet2cd, true, true >::pmul(), Eigen::internal::conj_helper< Packet2cf, Packet2cf, false, true >::pmul(), Eigen::internal::conj_helper< Packet2cf, Packet2cf, true, false >::pmul(), Eigen::internal::conj_helper< Packet2cf, Packet2cf, true, true >::pmul(), Eigen::internal::conj_helper< Packet4cf, Packet4cf, false, true >::pmul(), Eigen::internal::conj_helper< Packet4cf, Packet4cf, true, false >::pmul(), Eigen::internal::conj_helper< Packet4cf, Packet4cf, true, true >::pmul(), Eigen::internal::conj_helper< Scalar, Scalar, false, false >::pmul(), pmul< Packet2cf >(), predux_mul< Packet16f >(), predux_mul< Packet2cd >(), predux_mul< Packet2cf >(), predux_mul< Packet2d >(), predux_mul< Packet4cf >(), predux_mul< Packet4f >(), predux_mul< Packet8d >(), psin< Packet4f >(), psin< Packet8f >(), Eigen::internal::quat_product< Architecture::SSE, Derived, OtherDerived, double >::run(), Eigen::internal::etor_product_packet_impl< RowMajor, 1, Lhs, Rhs, Packet, LoadMode >::run(), and Eigen::internal::etor_product_packet_impl< ColMajor, 1, Lhs, Rhs, Packet, LoadMode >::run().

Here is the caller graph for this function:

pmul() [2/3]

template<>

std::complex< double > Eigen::internal::pmul ( const std::complex< double > &  a, const std::complex< double > &  b  )

inline

{ return std::complex<double>(real(a)*real(b) - imag(a)*imag(b), imag(a)*real(b) + real(a)*imag(b)); }

References imag(), and real().

Here is the call graph for this function:

pmul() [3/3]

template<>

std::complex< float > Eigen::internal::pmul ( const std::complex< float > &  a, const std::complex< float > &  b  )

inline

{ return std::complex<float>(real(a)*real(b) - imag(a)*imag(b), imag(a)*real(b) + real(a)*imag(b)); }

References imag(), and real().

Here is the call graph for this function:

pmul< Packet16f >()

template<>

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

                                                                  {
  return _mm512_mul_ps(a, b);
}

pmul< Packet1cd >() [1/2]

template<>

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

{
  #ifdef EIGEN_VECTORIZE_SSE3
  return Packet1cd(_mm_addsub_pd(_mm_mul_pd(_mm_movedup_pd(a.v), b.v),
                                 _mm_mul_pd(vec2d_swizzle1(a.v, 1, 1),
                                            vec2d_swizzle1(b.v, 1, 0))));
  #else
  const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x0,0x0,0x80000000,0x0));
  return Packet1cd(_mm_add_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 0, 0), b.v),
                              _mm_xor_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 1, 1),
                                                    vec2d_swizzle1(b.v, 1, 0)), mask)));
  #endif
}

References vec2d_swizzle1.

Referenced by predux_mul< Packet2cf >().

Here is the caller graph for this function:

pmul< Packet1cd >() [2/2]

template<>

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

{
  Packet2d a_re, a_im, v1, v2;
 
  // Permute and multiply the real parts of a and b
  a_re = vec_perm(a.v, a.v, p16uc_PSET64_HI);
  // Get the imaginary parts of a
  a_im = vec_perm(a.v, a.v, p16uc_PSET64_LO);
  // multiply a_re * b
  v1 = vec_madd(a_re, b.v, p2d_ZERO);
  // multiply a_im * b and get the conjugate result
  v2 = vec_madd(a_im, b.v, p2d_ZERO);
  v2 = (Packet2d) vec_sld((Packet4ui)v2, (Packet4ui)v2, 8);
  v2 = (Packet2d) vec_xor((Packet2d)v2, (Packet2d) p2ul_CONJ_XOR1);
 
  return Packet1cd(v1 + v2);
}

References p16uc_PSET64_HI, p16uc_PSET64_LO, and p2ul_CONJ_XOR1.

pmul< Packet2cd >()

template<>

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

{
  __m256d tmp1 = _mm256_shuffle_pd(a.v,a.v,0x0);
  __m256d even = _mm256_mul_pd(tmp1, b.v);
  __m256d tmp2 = _mm256_shuffle_pd(a.v,a.v,0xF);
  __m256d tmp3 = _mm256_shuffle_pd(b.v,b.v,0x5);
  __m256d odd  = _mm256_mul_pd(tmp2, tmp3);
  return Packet2cd(_mm256_addsub_pd(even, odd));
}

pmul< Packet2cf >() [1/4]

template<>

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

{
  Packet4f v1, v2;
 
  // Permute and multiply the real parts of a and b
  v1 = vec_perm(a.v, a.v, p16uc_PSET32_WODD);
  // Get the imaginary parts of a
  v2 = vec_perm(a.v, a.v, p16uc_PSET32_WEVEN);
  // multiply a_re * b 
  v1 = vec_madd(v1, b.v, p4f_ZERO);
  // multiply a_im * b and get the conjugate result
  v2 = vec_madd(v2, b.v, p4f_ZERO);
  v2 = reinterpret_cast<Packet4f>(pxor(v2, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR)));
  // permute back to a proper order
  v2 = vec_perm(v2, v2, p16uc_COMPLEX32_REV);
  
  return Packet2cf(padd<Packet4f>(v1, v2));
}

References p16uc_COMPLEX32_REV, p16uc_PSET32_WEVEN, p16uc_PSET32_WODD, p4ui_CONJ_XOR, padd< Packet4f >(), and pxor().

Referenced by predux_mul< Packet2cf >().

Here is the call graph for this function:

Here is the caller graph for this function:

pmul< Packet2cf >() [2/4]

template<>

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

{
  Packet4f v1, v2;
 
  // Get the real values of a | a1_re | a1_re | a2_re | a2_re |
  v1 = vcombine_f32(vdup_lane_f32(vget_low_f32(a.v), 0), vdup_lane_f32(vget_high_f32(a.v), 0));
  // Get the imag values of a | a1_im | a1_im | a2_im | a2_im |
  v2 = vcombine_f32(vdup_lane_f32(vget_low_f32(a.v), 1), vdup_lane_f32(vget_high_f32(a.v), 1));
  // Multiply the real a with b
  v1 = vmulq_f32(v1, b.v);
  // Multiply the imag a with b
  v2 = vmulq_f32(v2, b.v);
  // Conjugate v2 
  v2 = vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(v2), p4ui_CONJ_XOR()));
  // Swap real/imag elements in v2.
  v2 = vrev64q_f32(v2);
  // Add and return the result
  return Packet2cf(vaddq_f32(v1, v2));
}

References p4ui_CONJ_XOR.

pmul< Packet2cf >() [3/4]

template<>

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

{
  #ifdef EIGEN_VECTORIZE_SSE3
  return Packet2cf(_mm_addsub_ps(_mm_mul_ps(_mm_moveldup_ps(a.v), b.v),
                                 _mm_mul_ps(_mm_movehdup_ps(a.v),
                                            vec4f_swizzle1(b.v, 1, 0, 3, 2))));
//   return Packet2cf(_mm_addsub_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v),
//                                  _mm_mul_ps(vec4f_swizzle1(a.v, 1, 1, 3, 3),
//                                             vec4f_swizzle1(b.v, 1, 0, 3, 2))));
  #else
  const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x00000000,0x80000000,0x00000000));
  return Packet2cf(_mm_add_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v),
                              _mm_xor_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 1, 1, 3, 3),
                                                    vec4f_swizzle1(b.v, 1, 0, 3, 2)), mask)));
  #endif
}

References vec4f_swizzle1.

pmul< Packet2cf >() [4/4]

template<>

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

{
  Packet2cf res;
  res.v.v4f[0] = pmul(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[0])), Packet1cd(reinterpret_cast<Packet2d>(b.v.v4f[0]))).v;
  res.v.v4f[1] = pmul(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[1])), Packet1cd(reinterpret_cast<Packet2d>(b.v.v4f[1]))).v;
  return res;
}

References pmul(), Eigen::internal::Packet2cf::v, and Eigen::internal::Packet4f::v4f.

Here is the call graph for this function:

pmul< Packet2d >() [1/2]

template<>

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

{ return _mm_mul_pd(a,b); }

pmul< Packet2d >() [2/2]

template<>

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

{ return (a * b); }

pmul< Packet4cf >()

template<>

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

{
  __m256 tmp1 = _mm256_mul_ps(_mm256_moveldup_ps(a.v), b.v);
  __m256 tmp2 = _mm256_mul_ps(_mm256_movehdup_ps(a.v), _mm256_permute_ps(b.v, _MM_SHUFFLE(2,3,0,1)));
  __m256 result = _mm256_addsub_ps(tmp1, tmp2);
  return Packet4cf(result);
}

pmul< Packet4d >()

template<>

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

{ return _mm256_mul_pd(a,b); }

pmul< Packet4f >() [1/4]

template<>

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

{ return vec_madd(a,b, p4f_MZERO); }

References p4f_MZERO.

Referenced by pdiv< Packet2cf >().

Here is the caller graph for this function:

pmul< Packet4f >() [2/4]

template<>

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

{ return vmulq_f32(a,b); }

pmul< Packet4f >() [3/4]

template<>

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

{ return _mm_mul_ps(a,b); }

pmul< Packet4f >() [4/4]

template<>

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

{
  Packet4f c;
  c.v4f[0] = a.v4f[0] * b.v4f[0];
  c.v4f[1] = a.v4f[1] * b.v4f[1];
  return c;
}

pmul< Packet4i >() [1/4]

template<>

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

{ return a * b; }

Referenced by pmadd().

Here is the caller graph for this function:

pmul< Packet4i >() [2/4]

template<>

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

{ return vmulq_s32(a,b); }

pmul< Packet4i >() [3/4]

template<>

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

{
#ifdef EIGEN_VECTORIZE_SSE4_1
  return _mm_mullo_epi32(a,b);
#else
  // this version is slightly faster than 4 scalar products
  return vec4i_swizzle1(
            vec4i_swizzle2(
              _mm_mul_epu32(a,b),
              _mm_mul_epu32(vec4i_swizzle1(a,1,0,3,2),
                            vec4i_swizzle1(b,1,0,3,2)),
              0,2,0,2),
            0,2,1,3);
#endif
}

References vec4i_swizzle1, and vec4i_swizzle2.

pmul< Packet4i >() [4/4]

template<>

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

{ return (a * b); }

pmul< Packet8d >()

template<>

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

                                                               {
  return _mm512_mul_pd(a, b);
}

pmul< Packet8f >()

template<>

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

{ return _mm256_mul_ps(a,b); }

pnegate() [1/23]

template<typename Packet >

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

inline

{ return -a; }

pnegate() [2/23]

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pnegate

(

const Packet16f &

a

)

                                                          {
  return _mm512_sub_ps(_mm512_set1_ps(0.0), a);
}

pnegate() [3/23]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pnegate

(

const Packet1cd &

a

)

{ return Packet1cd(pnegate(Packet2d(a.v))); }

References pnegate().

Here is the call graph for this function:

pnegate() [4/23]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pnegate

(

const Packet1cd &

a

)

{ return Packet1cd(pnegate(Packet2d(a.v))); }

References pnegate().

Here is the call graph for this function:

pnegate() [5/23]

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pnegate

(

const Packet2cd &

a

)

{ return Packet2cd(pnegate(a.v)); }

References pnegate().

Here is the call graph for this function:

pnegate() [6/23]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pnegate

(

const Packet2cf &

a

)

{ return Packet2cf(pnegate(a.v)); }

References pnegate().

Referenced by Eigen::internal::scalar_opposite_op< Scalar >::packetOp(), pnegate(), pnegate(), pnegate(), and pnegate().

Here is the call graph for this function:

Here is the caller graph for this function:

pnegate() [7/23]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pnegate

(

const Packet2cf &

a

)

{ return Packet2cf(pnegate<Packet4f>(a.v)); }

pnegate() [8/23]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pnegate

(

const Packet2cf &

a

)

{
  const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x80000000,0x80000000,0x80000000));
  return Packet2cf(_mm_xor_ps(a.v,mask));
}

pnegate() [9/23]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pnegate

(

const Packet2cf &

a

)

{ return Packet2cf(pnegate(Packet4f(a.v))); }

References pnegate().

Here is the call graph for this function:

pnegate() [10/23]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pnegate

(

const Packet2d &

a

)

{
  const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0x0,0x80000000,0x0,0x80000000));
  return _mm_xor_pd(a,mask);
}

pnegate() [11/23]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pnegate

(

const Packet2d &

a

)

{ return (-a); }

pnegate() [12/23]

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pnegate

(

const Packet4cf &

a

)

{
  return Packet4cf(pnegate(a.v));
}

References pnegate().

Here is the call graph for this function:

pnegate() [13/23]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pnegate

(

const Packet4d &

a

)

{
  return _mm256_sub_pd(_mm256_set1_pd(0.0),a);
}

pnegate() [14/23]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pnegate

(

const Packet4f &

a

)

{ return p4f_ZERO - a; }

pnegate() [15/23]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pnegate

(

const Packet4f &

a

)

{ return vnegq_f32(a); }

pnegate() [16/23]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pnegate

(

const Packet4f &

a

)

{
  const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x80000000,0x80000000,0x80000000));
  return _mm_xor_ps(a,mask);
}

pnegate() [17/23]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pnegate

(

const Packet4f &

a

)

{
  Packet4f c;
  c.v4f[0] = -a.v4f[0];
  c.v4f[1] = -a.v4f[1];
  return c;
}

pnegate() [18/23]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pnegate

(

const Packet4i &

a

)

{ return p4i_ZERO - a; }

pnegate() [19/23]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pnegate

(

const Packet4i &

a

)

{ return vnegq_s32(a); }

pnegate() [20/23]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pnegate

(

const Packet4i &

a

)

{
  return psub(Packet4i(_mm_setr_epi32(0,0,0,0)), a);
}

References psub().

Here is the call graph for this function:

pnegate() [21/23]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pnegate

(

const Packet4i &

a

)

{ return (-a); }

pnegate() [22/23]

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pnegate

(

const Packet8d &

a

)

                                                        {
  return _mm512_sub_pd(_mm512_set1_pd(0.0), a);
}

pnegate() [23/23]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pnegate

(

const Packet8f &

a

)

{
  return _mm256_sub_ps(_mm256_set1_ps(0.0),a);
}

por()

template<typename Packet >

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

inline

{ return a | b; }

Referenced by plog< Packet4f >().

Here is the caller graph for this function:

por< Packet16f >()

template<>

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

                                                                 {
#ifdef EIGEN_VECTORIZE_AVX512DQ
  return _mm512_or_ps(a, b);
#else
  Packet16f res = _mm512_undefined_ps();
  Packet4f lane0_a = _mm512_extractf32x4_ps(a, 0);
  Packet4f lane0_b = _mm512_extractf32x4_ps(b, 0);
  res = _mm512_insertf32x4(res, _mm_or_ps(lane0_a, lane0_b), 0);
 
  Packet4f lane1_a = _mm512_extractf32x4_ps(a, 1);
  Packet4f lane1_b = _mm512_extractf32x4_ps(b, 1);
  res = _mm512_insertf32x4(res, _mm_or_ps(lane1_a, lane1_b), 1);
 
  Packet4f lane2_a = _mm512_extractf32x4_ps(a, 2);
  Packet4f lane2_b = _mm512_extractf32x4_ps(b, 2);
  res = _mm512_insertf32x4(res, _mm_or_ps(lane2_a, lane2_b), 2);
 
  Packet4f lane3_a = _mm512_extractf32x4_ps(a, 3);
  Packet4f lane3_b = _mm512_extractf32x4_ps(b, 3);
  res = _mm512_insertf32x4(res, _mm_or_ps(lane3_a, lane3_b), 3);
 
  return res;
#endif
}

por< Packet1cd >() [1/2]

template<>

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

{ return Packet1cd(_mm_or_pd(a.v,b.v)); }

por< Packet1cd >() [2/2]

template<>

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

{ return Packet1cd(vec_or(a.v,b.v)); }

por< Packet2cd >()

template<>

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

{ return Packet2cd(_mm256_or_pd(a.v,b.v)); }

por< Packet2cf >() [1/4]

template<>

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

{ return Packet2cf(por<Packet4f>(a.v, b.v)); }

References por< Packet4f >().

Here is the call graph for this function:

por< Packet2cf >() [2/4]

template<>

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

{
  return Packet2cf(vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(a.v),vreinterpretq_u32_f32(b.v))));
}

por< Packet2cf >() [3/4]

template<>

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

{ return Packet2cf(_mm_or_ps(a.v,b.v)); }

por< Packet2cf >() [4/4]

template<>

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

{ return Packet2cf(por<Packet4f>(a.v,b.v)); }

References por< Packet4f >().

Here is the call graph for this function:

por< Packet2d >() [1/2]

template<>

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

{ return _mm_or_pd(a,b); }

por< Packet2d >() [2/2]

template<>

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

{ return vec_or(a, b); }

por< Packet4cf >()

template<>

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

{ return Packet4cf(_mm256_or_ps(a.v,b.v)); }

por< Packet4d >()

template<>

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

{ return _mm256_or_pd(a,b); }

por< Packet4f >() [1/4]

template<>

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

{ return vec_or(a, b); }

Referenced by por< Packet2cf >().

Here is the caller graph for this function:

por< Packet4f >() [2/4]

template<>

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

{
  return vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b)));
}

por< Packet4f >() [3/4]

template<>

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

{ return _mm_or_ps(a,b); }

por< Packet4f >() [4/4]

template<>

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

{
  Packet4f res;
  res.v4f[0] = pand(a.v4f[0], b.v4f[0]);
  res.v4f[1] = pand(a.v4f[1], b.v4f[1]);
  return res;
}

References pand(), and Eigen::internal::Packet4f::v4f.

Here is the call graph for this function:

por< Packet4i >() [1/4]

template<>

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

{ return vec_or(a, b); }

por< Packet4i >() [2/4]

template<>

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

{ return vorrq_s32(a,b); }

por< Packet4i >() [3/4]

template<>

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

{ return _mm_or_si128(a,b); }

por< Packet4i >() [4/4]

template<>

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

{ return vec_or(a, b); }

por< Packet8d >()

template<>

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

                                                              {
#ifdef EIGEN_VECTORIZE_AVX512DQ
  return _mm512_or_pd(a, b);
#else
  Packet8d res = _mm512_undefined_pd();
  Packet4d lane0_a = _mm512_extractf64x4_pd(a, 0);
  Packet4d lane0_b = _mm512_extractf64x4_pd(b, 0);
  res = _mm512_insertf64x4(res, _mm256_or_pd(lane0_a, lane0_b), 0);
 
  Packet4d lane1_a = _mm512_extractf64x4_pd(a, 1);
  Packet4d lane1_b = _mm512_extractf64x4_pd(b, 1);
  res = _mm512_insertf64x4(res, _mm256_or_pd(lane1_a, lane1_b), 1);
 
  return res;
#endif
}

por< Packet8f >()

template<>

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

{ return _mm256_or_ps(a,b); }

positive_real_hypot()

template<typename RealScalar >

EIGEN_STRONG_INLINE RealScalar Eigen::internal::positive_real_hypot	(	const RealScalar &	x,
		const RealScalar &	y
	)

{
  EIGEN_USING_STD_MATH(sqrt);
  RealScalar p, qp;
  p = numext::maxi(x,y);
  if(p==RealScalar(0)) return RealScalar(0);
  qp = numext::mini(y,x) / p;    
  return p * sqrt(RealScalar(1) + qp*qp);
}

References Eigen::numext::maxi(), Eigen::numext::mini(), sqrt(), and y.

Referenced by Eigen::internal::scalar_hypot_op< Scalar, Scalar >::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

predux()

template<typename Packet >

EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type Eigen::internal::predux ( const Packet &  a )

inline

{ return a; }

Referenced by Eigen::internal::scalar_sum_op< LhsScalar, RhsScalar >::predux(), predux< Packet2cd >(), predux< Packet4cf >(), predux< Packet4d >(), predux< Packet8f >(), predux_mul< Packet2cd >(), Eigen::internal::general_matrix_vector_product< Index, LhsScalar, LhsMapper, RowMajor, ConjugateLhs, RhsScalar, RhsMapper, ConjugateRhs, Version >::run(), and Eigen::internal::selfadjoint_matrix_vector_product< Scalar, Index, StorageOrder, UpLo, ConjugateLhs, ConjugateRhs, Version >::run().

Here is the caller graph for this function:

predux< Packet16f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet16f >

(

const Packet16f &

a

)

                                                                {
  //#ifdef EIGEN_VECTORIZE_AVX512DQ
#if 0
  Packet8f lane0 = _mm512_extractf32x8_ps(a, 0);
  Packet8f lane1 = _mm512_extractf32x8_ps(a, 1);
  Packet8f sum = padd(lane0, lane1);
  Packet8f tmp0 = _mm256_hadd_ps(sum, _mm256_permute2f128_ps(a, a, 1));
  tmp0 = _mm256_hadd_ps(tmp0, tmp0);
  return pfirst(_mm256_hadd_ps(tmp0, tmp0));
#else
  Packet4f lane0 = _mm512_extractf32x4_ps(a, 0);
  Packet4f lane1 = _mm512_extractf32x4_ps(a, 1);
  Packet4f lane2 = _mm512_extractf32x4_ps(a, 2);
  Packet4f lane3 = _mm512_extractf32x4_ps(a, 3);
  Packet4f sum = padd(padd(lane0, lane1), padd(lane2, lane3));
  sum = _mm_hadd_ps(sum, sum);
  sum = _mm_hadd_ps(sum, _mm_permute_ps(sum, 1));
  return pfirst(sum);
#endif
}

References padd(), and pfirst().

Here is the call graph for this function:

predux< Packet1cd >() [1/2]

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux< Packet1cd >

(

const Packet1cd &

a

)

{
  return pfirst(a);
}

References pfirst().

Here is the call graph for this function:

predux< Packet1cd >() [2/2]

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux< Packet1cd >

(

const Packet1cd &

a

)

{
  return pfirst(a);
}

References pfirst().

Here is the call graph for this function:

predux< Packet2cd >()

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux< Packet2cd >

(

const Packet2cd &

a

)

{
  return predux(padd(Packet1cd(_mm256_extractf128_pd(a.v,0)),
                     Packet1cd(_mm256_extractf128_pd(a.v,1))));
}

References padd(), and predux().

Here is the call graph for this function:

predux< Packet2cf >() [1/4]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux< Packet2cf >

(

const Packet2cf &

a

)

{
  Packet4f b;
  b = vec_sld(a.v, a.v, 8);
  b = padd<Packet4f>(a.v, b);
  return pfirst<Packet2cf>(Packet2cf(b));
}

References padd< Packet4f >(), and pfirst< Packet2cf >().

Here is the call graph for this function:

predux< Packet2cf >() [2/4]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux< Packet2cf >

(

const Packet2cf &

a

)

{
  float32x2_t a1, a2;
  std::complex<float> s;
 
  a1 = vget_low_f32(a.v);
  a2 = vget_high_f32(a.v);
  a2 = vadd_f32(a1, a2);
  vst1_f32((float *)&s, a2);
 
  return s;
}

predux< Packet2cf >() [3/4]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux< Packet2cf >

(

const Packet2cf &

a

)

{
  return pfirst(Packet2cf(_mm_add_ps(a.v, _mm_movehl_ps(a.v,a.v))));
}

References pfirst().

Here is the call graph for this function:

predux< Packet2cf >() [4/4]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux< Packet2cf >

(

const Packet2cf &

a

)

{
  std::complex<float> res;
  Packet1cd b = padd<Packet1cd>(a.cd[0], a.cd[1]);
  vec_st2f(b.v, (float*)&res);
  return res;
}

References padd< Packet1cd >().

Here is the call graph for this function:

predux< Packet2d >() [1/2]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux< Packet2d >

(

const Packet2d &

a

)

{
  // Disable SSE3 _mm_hadd_pd that is extremely slow on all existing Intel's architectures
  // (from Nehalem to Haswell)
// #ifdef EIGEN_VECTORIZE_SSE3
//   return pfirst<Packet2d>(_mm_hadd_pd(a, a));
// #else
  return pfirst<Packet2d>(_mm_add_sd(a, _mm_unpackhi_pd(a,a)));
// #endif
}

References pfirst< Packet2d >().

Referenced by predux< Packet4f >().

Here is the call graph for this function:

Here is the caller graph for this function:

predux< Packet2d >() [2/2]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux< Packet2d >

(

const Packet2d &

a

)

{
  Packet2d b, sum;
  b   = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(a), reinterpret_cast<Packet4i>(a), 8));
  sum = padd<Packet2d>(a, b);
  return pfirst(sum);
}

References padd< Packet2d >(), and pfirst().

Here is the call graph for this function:

predux< Packet4cf >()

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux< Packet4cf >

(

const Packet4cf &

a

)

{
  return predux(padd(Packet2cf(_mm256_extractf128_ps(a.v,0)),
                     Packet2cf(_mm256_extractf128_ps(a.v,1))));
}

References padd(), and predux().

Here is the call graph for this function:

predux< Packet4d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux< Packet4d >

(

const Packet4d &

a

)

{
  return predux(Packet2d(_mm_add_pd(_mm256_castpd256_pd128(a),_mm256_extractf128_pd(a,1))));
}

References predux().

Here is the call graph for this function:

predux< Packet4f >() [1/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet4f >

(

const Packet4f &

a

)

{
  Packet4f b, sum;
  b   = vec_sld(a, a, 8);
  sum = a + b;
  b   = vec_sld(sum, sum, 4);
  sum += b;
  return pfirst(sum);
}

References pfirst().

Here is the call graph for this function:

predux< Packet4f >() [2/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet4f >

(

const Packet4f &

a

)

{
  float32x2_t a_lo, a_hi, sum;
 
  a_lo = vget_low_f32(a);
  a_hi = vget_high_f32(a);
  sum = vpadd_f32(a_lo, a_hi);
  sum = vpadd_f32(sum, sum);
  return vget_lane_f32(sum, 0);
}

predux< Packet4f >() [3/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet4f >

(

const Packet4f &

a

)

{
  // Disable SSE3 _mm_hadd_pd that is extremely slow on all existing Intel's architectures
  // (from Nehalem to Haswell)
// #ifdef EIGEN_VECTORIZE_SSE3
//   Packet4f tmp = _mm_add_ps(a, vec4f_swizzle1(a,2,3,2,3));
//   return pfirst<Packet4f>(_mm_hadd_ps(tmp, tmp));
// #else
  Packet4f tmp = _mm_add_ps(a, _mm_movehl_ps(a,a));
  return pfirst<Packet4f>(_mm_add_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
// #endif
}

References pfirst< Packet4f >().

Here is the call graph for this function:

predux< Packet4f >() [4/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet4f >

(

const Packet4f &

a

)

{
  Packet2d sum;
  sum = padd<Packet2d>(a.v4f[0], a.v4f[1]);
  double first = predux<Packet2d>(sum);
  return static_cast<float>(first);
}

References padd< Packet2d >(), and predux< Packet2d >().

Here is the call graph for this function:

predux< Packet4i >() [1/4]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux< Packet4i >

(

const Packet4i &

a

)

{
  Packet4i sum;
  sum = vec_sums(a, p4i_ZERO);
#ifdef _BIG_ENDIAN
  sum = vec_sld(sum, p4i_ZERO, 12);
#else
  sum = vec_sld(p4i_ZERO, sum, 4);
#endif
  return pfirst(sum);
}

References pfirst().

Here is the call graph for this function:

predux< Packet4i >() [2/4]

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::predux< Packet4i >

(

const Packet4i &

a

)

{
  int32x2_t a_lo, a_hi, sum;
 
  a_lo = vget_low_s32(a);
  a_hi = vget_high_s32(a);
  sum = vpadd_s32(a_lo, a_hi);
  sum = vpadd_s32(sum, sum);
  return vget_lane_s32(sum, 0);
}

predux< Packet4i >() [3/4]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux< Packet4i >

(

const Packet4i &

a

)

{
  Packet4i tmp = _mm_add_epi32(a, _mm_unpackhi_epi64(a,a));
  return pfirst(tmp) + pfirst<Packet4i>(_mm_shuffle_epi32(tmp, 1));
}

References pfirst(), and pfirst< Packet4i >().

Here is the call graph for this function:

predux< Packet4i >() [4/4]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux< Packet4i >

(

const Packet4i &

a

)

{
  Packet4i b, sum;
  b   = vec_sld(a, a, 8);
  sum = padd<Packet4i>(a, b);
  b   = vec_sld(sum, sum, 4);
  sum = padd<Packet4i>(sum, b);
  return pfirst(sum);
}

References padd< Packet4i >(), and pfirst().

Here is the call graph for this function:

predux< Packet8d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux< Packet8d >

(

const Packet8d &

a

)

                                                               {
  Packet4d lane0 = _mm512_extractf64x4_pd(a, 0);
  Packet4d lane1 = _mm512_extractf64x4_pd(a, 1);
  Packet4d sum = padd(lane0, lane1);
  Packet4d tmp0 = _mm256_hadd_pd(sum, _mm256_permute2f128_pd(sum, sum, 1));
  return pfirst(_mm256_hadd_pd(tmp0, tmp0));
}

References padd(), and pfirst().

Here is the call graph for this function:

predux< Packet8f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet8f >

(

const Packet8f &

a

)

{
  return predux(Packet4f(_mm_add_ps(_mm256_castps256_ps128(a),_mm256_extractf128_ps(a,1))));
}

References predux().

Here is the call graph for this function:

predux_downto4() [1/2]

template<typename Packet >

const DoublePacket< Packet > & Eigen::internal::predux_downto4

(

const DoublePacket< Packet > &

a

)

{
  return a;
}

predux_downto4() [2/2]

template<typename Packet >

EIGEN_DEVICE_FUNC conditional<(unpacket_traits< Packet >::size%8)==0, typenameunpacket_traits< Packet >::half, Packet >::type Eigen::internal::predux_downto4 ( const Packet &  a )

inline

{ return a; }

Referenced by Eigen::internal::gebp_kernel< LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >::operator()().

Here is the caller graph for this function:

predux_downto4< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::predux_downto4< Packet16f >

(

const Packet16f &

a

)

                                                                           {
#ifdef EIGEN_VECTORIZE_AVX512DQ
  Packet8f lane0 = _mm512_extractf32x8_ps(a, 0);
  Packet8f lane1 = _mm512_extractf32x8_ps(a, 1);
  return padd(lane0, lane1);
#else
  Packet4f lane0 = _mm512_extractf32x4_ps(a, 0);
  Packet4f lane1 = _mm512_extractf32x4_ps(a, 1);
  Packet4f lane2 = _mm512_extractf32x4_ps(a, 2);
  Packet4f lane3 = _mm512_extractf32x4_ps(a, 3);
  Packet4f sum0 = padd(lane0, lane2);
  Packet4f sum1 = padd(lane1, lane3);
  return _mm256_insertf128_ps(_mm256_castps128_ps256(sum0), sum1, 1);
#endif
}

References padd().

Here is the call graph for this function:

predux_downto4< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::predux_downto4< Packet8d >

(

const Packet8d &

a

)

                                                                         {
  Packet4d lane0 = _mm512_extractf64x4_pd(a, 0);
  Packet4d lane1 = _mm512_extractf64x4_pd(a, 1);
  Packet4d res = padd(lane0, lane1);
  return res;
}

References padd().

Here is the call graph for this function:

predux_downto4< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::predux_downto4< Packet8f >

(

const Packet8f &

a

)

{
  return _mm_add_ps(_mm256_castps256_ps128(a),_mm256_extractf128_ps(a,1));
}

predux_max()

template<typename Packet >

EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type Eigen::internal::predux_max ( const Packet &  a )

inline

{ return a; }

Referenced by Eigen::internal::scalar_max_op< LhsScalar, RhsScalar >::predux().

Here is the caller graph for this function:

predux_max< Packet16f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_max< Packet16f >

(

const Packet16f &

a

)

                                                                    {
  Packet4f lane0 = _mm512_extractf32x4_ps(a, 0);
  Packet4f lane1 = _mm512_extractf32x4_ps(a, 1);
  Packet4f lane2 = _mm512_extractf32x4_ps(a, 2);
  Packet4f lane3 = _mm512_extractf32x4_ps(a, 3);
  Packet4f res = _mm_max_ps(_mm_max_ps(lane0, lane1), _mm_max_ps(lane2, lane3));
  res = _mm_max_ps(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 3, 2)));
  return pfirst(_mm_max_ps(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 0, 1))));
}

References pfirst().

Here is the call graph for this function:

predux_max< Packet2d >() [1/2]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_max< Packet2d >

(

const Packet2d &

a

)

{
  return pfirst<Packet2d>(_mm_max_sd(a, _mm_unpackhi_pd(a,a)));
}

References pfirst< Packet2d >().

Here is the call graph for this function:

predux_max< Packet2d >() [2/2]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_max< Packet2d >

(

const Packet2d &

a

)

{
  return pfirst(pmax<Packet2d>(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(a), reinterpret_cast<Packet4i>(a), 8))));
}

References pfirst(), and pmax< Packet2d >().

Here is the call graph for this function:

predux_max< Packet4d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_max< Packet4d >

(

const Packet4d &

a

)

{
  Packet4d tmp = _mm256_max_pd(a, _mm256_permute2f128_pd(a,a,1));
  return pfirst(_mm256_max_pd(tmp, _mm256_shuffle_pd(tmp, tmp, 1)));
}

References pfirst().

Here is the call graph for this function:

predux_max< Packet4f >() [1/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_max< Packet4f >

(

const Packet4f &

a

)

{
  Packet4f b, res;
  b = vec_max(a, vec_sld(a, a, 8));
  res = vec_max(b, vec_sld(b, b, 4));
  return pfirst(res);
}

References pfirst().

Here is the call graph for this function:

predux_max< Packet4f >() [2/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_max< Packet4f >

(

const Packet4f &

a

)

{
  float32x2_t a_lo, a_hi, max;
 
  a_lo = vget_low_f32(a);
  a_hi = vget_high_f32(a);
  max = vpmax_f32(a_lo, a_hi);
  max = vpmax_f32(max, max);
 
  return vget_lane_f32(max, 0);
}

predux_max< Packet4f >() [3/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_max< Packet4f >

(

const Packet4f &

a

)

{
  Packet4f tmp = _mm_max_ps(a, _mm_movehl_ps(a,a));
  return pfirst<Packet4f>(_mm_max_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
}

References pfirst< Packet4f >().

Here is the call graph for this function:

predux_max< Packet4f >() [4/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_max< Packet4f >

(

const Packet4f &

a

)

{
  Packet2d b, res;
  b   = pmax<Packet2d>(a.v4f[0], a.v4f[1]);
  res = pmax<Packet2d>(b, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(b), reinterpret_cast<Packet4i>(b), 8)));
  return static_cast<float>(pfirst(res));
}

References pfirst(), and pmax< Packet2d >().

Here is the call graph for this function:

predux_max< Packet4i >() [1/4]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_max< Packet4i >

(

const Packet4i &

a

)

{
  Packet4i b, res;
  b = vec_max(a, vec_sld(a, a, 8));
  res = vec_max(b, vec_sld(b, b, 4));
  return pfirst(res);
}

References pfirst().

Here is the call graph for this function:

predux_max< Packet4i >() [2/4]

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::predux_max< Packet4i >

(

const Packet4i &

a

)

{
  int32x2_t a_lo, a_hi, max;
 
  a_lo = vget_low_s32(a);
  a_hi = vget_high_s32(a);
  max = vpmax_s32(a_lo, a_hi);
  max = vpmax_s32(max, max);
 
  return vget_lane_s32(max, 0);
}

predux_max< Packet4i >() [3/4]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_max< Packet4i >

(

const Packet4i &

a

)

{
#ifdef EIGEN_VECTORIZE_SSE4_1
  Packet4i tmp = _mm_max_epi32(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0,0,3,2)));
  return pfirst<Packet4i>(_mm_max_epi32(tmp,_mm_shuffle_epi32(tmp, 1)));
#else
  // after some experiments, it is seems this is the fastest way to implement it
  // for GCC (eg., it does not like using std::min after the pstore !!)
  EIGEN_ALIGN16 int aux[4];
  pstore(aux, a);
  int aux0 = aux[0]>aux[1] ? aux[0] : aux[1];
  int aux2 = aux[2]>aux[3] ? aux[2] : aux[3];
  return aux0>aux2 ? aux0 : aux2;
#endif // EIGEN_VECTORIZE_SSE4_1
}

References EIGEN_ALIGN16, pfirst< Packet4i >(), and pstore().

Here is the call graph for this function:

predux_max< Packet4i >() [4/4]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_max< Packet4i >

(

const Packet4i &

a

)

{
  Packet4i b, res;
  b = pmax<Packet4i>(a, vec_sld(a, a, 8));
  res = pmax<Packet4i>(b, vec_sld(b, b, 4));
  return pfirst(res);
}

References pfirst(), and pmax< Packet4i >().

Here is the call graph for this function:

predux_max< Packet8d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_max< Packet8d >

(

const Packet8d &

a

)

                                                                   {
  Packet4d lane0 = _mm512_extractf64x4_pd(a, 0);
  Packet4d lane1 = _mm512_extractf64x4_pd(a, 1);
  Packet4d res = _mm256_max_pd(lane0, lane1);
  res = _mm256_max_pd(res, _mm256_permute2f128_pd(res, res, 1));
  return pfirst(_mm256_max_pd(res, _mm256_shuffle_pd(res, res, 1)));
}

References pfirst().

Here is the call graph for this function:

predux_max< Packet8f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_max< Packet8f >

(

const Packet8f &

a

)

{
  Packet8f tmp = _mm256_max_ps(a, _mm256_permute2f128_ps(a,a,1));
  tmp = _mm256_max_ps(tmp, _mm256_shuffle_ps(tmp,tmp,_MM_SHUFFLE(1,0,3,2)));
  return pfirst(_mm256_max_ps(tmp, _mm256_shuffle_ps(tmp,tmp,1)));
}

References pfirst().

Here is the call graph for this function:

predux_min()

template<typename Packet >

EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type Eigen::internal::predux_min ( const Packet &  a )

inline

{ return a; }

Referenced by Eigen::internal::scalar_min_op< LhsScalar, RhsScalar >::predux().

Here is the caller graph for this function:

predux_min< Packet16f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_min< Packet16f >

(

const Packet16f &

a

)

                                                                    {
  Packet4f lane0 = _mm512_extractf32x4_ps(a, 0);
  Packet4f lane1 = _mm512_extractf32x4_ps(a, 1);
  Packet4f lane2 = _mm512_extractf32x4_ps(a, 2);
  Packet4f lane3 = _mm512_extractf32x4_ps(a, 3);
  Packet4f res = _mm_min_ps(_mm_min_ps(lane0, lane1), _mm_min_ps(lane2, lane3));
  res = _mm_min_ps(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 3, 2)));
  return pfirst(_mm_min_ps(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 0, 1))));
}

References pfirst().

Here is the call graph for this function:

predux_min< Packet2d >() [1/2]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_min< Packet2d >

(

const Packet2d &

a

)

{
  return pfirst<Packet2d>(_mm_min_sd(a, _mm_unpackhi_pd(a,a)));
}

References pfirst< Packet2d >().

Here is the call graph for this function:

predux_min< Packet2d >() [2/2]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_min< Packet2d >

(

const Packet2d &

a

)

{
  return pfirst(pmin<Packet2d>(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(a), reinterpret_cast<Packet4i>(a), 8))));
}

References pfirst(), and pmin< Packet2d >().

Here is the call graph for this function:

predux_min< Packet4d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_min< Packet4d >

(

const Packet4d &

a

)

{
  Packet4d tmp = _mm256_min_pd(a, _mm256_permute2f128_pd(a,a,1));
  return pfirst(_mm256_min_pd(tmp, _mm256_shuffle_pd(tmp, tmp, 1)));
}

References pfirst().

Here is the call graph for this function:

predux_min< Packet4f >() [1/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_min< Packet4f >

(

const Packet4f &

a

)

{
  Packet4f b, res;
  b = vec_min(a, vec_sld(a, a, 8));
  res = vec_min(b, vec_sld(b, b, 4));
  return pfirst(res);
}

References pfirst().

Here is the call graph for this function:

predux_min< Packet4f >() [2/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_min< Packet4f >

(

const Packet4f &

a

)

{
  float32x2_t a_lo, a_hi, min;
 
  a_lo = vget_low_f32(a);
  a_hi = vget_high_f32(a);
  min = vpmin_f32(a_lo, a_hi);
  min = vpmin_f32(min, min);
 
  return vget_lane_f32(min, 0);
}

predux_min< Packet4f >() [3/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_min< Packet4f >

(

const Packet4f &

a

)

{
  Packet4f tmp = _mm_min_ps(a, _mm_movehl_ps(a,a));
  return pfirst<Packet4f>(_mm_min_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
}

References pfirst< Packet4f >().

Here is the call graph for this function:

predux_min< Packet4f >() [4/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_min< Packet4f >

(

const Packet4f &

a

)

{
  Packet2d b, res;
  b   = pmin<Packet2d>(a.v4f[0], a.v4f[1]);
  res = pmin<Packet2d>(b, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(b), reinterpret_cast<Packet4i>(b), 8)));
  return static_cast<float>(pfirst(res));
}

References pfirst(), and pmin< Packet2d >().

Here is the call graph for this function:

predux_min< Packet4i >() [1/4]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_min< Packet4i >

(

const Packet4i &

a

)

{
  Packet4i b, res;
  b = vec_min(a, vec_sld(a, a, 8));
  res = vec_min(b, vec_sld(b, b, 4));
  return pfirst(res);
}

References pfirst().

Here is the call graph for this function:

predux_min< Packet4i >() [2/4]

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::predux_min< Packet4i >

(

const Packet4i &

a

)

{
  int32x2_t a_lo, a_hi, min;
 
  a_lo = vget_low_s32(a);
  a_hi = vget_high_s32(a);
  min = vpmin_s32(a_lo, a_hi);
  min = vpmin_s32(min, min);
  
  return vget_lane_s32(min, 0);
}

predux_min< Packet4i >() [3/4]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_min< Packet4i >

(

const Packet4i &

a

)

{
#ifdef EIGEN_VECTORIZE_SSE4_1
  Packet4i tmp = _mm_min_epi32(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0,0,3,2)));
  return pfirst<Packet4i>(_mm_min_epi32(tmp,_mm_shuffle_epi32(tmp, 1)));
#else
  // after some experiments, it is seems this is the fastest way to implement it
  // for GCC (eg., it does not like using std::min after the pstore !!)
  EIGEN_ALIGN16 int aux[4];
  pstore(aux, a);
  int aux0 = aux[0]<aux[1] ? aux[0] : aux[1];
  int aux2 = aux[2]<aux[3] ? aux[2] : aux[3];
  return aux0<aux2 ? aux0 : aux2;
#endif // EIGEN_VECTORIZE_SSE4_1
}

References EIGEN_ALIGN16, pfirst< Packet4i >(), and pstore().

Here is the call graph for this function:

predux_min< Packet4i >() [4/4]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_min< Packet4i >

(

const Packet4i &

a

)

{
  Packet4i b, res;
  b   = pmin<Packet4i>(a, vec_sld(a, a, 8));
  res = pmin<Packet4i>(b, vec_sld(b, b, 4));
  return pfirst(res);
}

References pfirst(), and pmin< Packet4i >().

Here is the call graph for this function:

predux_min< Packet8d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_min< Packet8d >

(

const Packet8d &

a

)

                                                                   {
  Packet4d lane0 = _mm512_extractf64x4_pd(a, 0);
  Packet4d lane1 = _mm512_extractf64x4_pd(a, 1);
  Packet4d res = _mm256_min_pd(lane0, lane1);
  res = _mm256_min_pd(res, _mm256_permute2f128_pd(res, res, 1));
  return pfirst(_mm256_min_pd(res, _mm256_shuffle_pd(res, res, 1)));
}

References pfirst().

Here is the call graph for this function:

predux_min< Packet8f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_min< Packet8f >

(

const Packet8f &

a

)

{
  Packet8f tmp = _mm256_min_ps(a, _mm256_permute2f128_ps(a,a,1));
  tmp = _mm256_min_ps(tmp, _mm256_shuffle_ps(tmp,tmp,_MM_SHUFFLE(1,0,3,2)));
  return pfirst(_mm256_min_ps(tmp, _mm256_shuffle_ps(tmp,tmp,1)));
}

References pfirst().

Here is the call graph for this function:

predux_mul()

template<typename Packet >

EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type Eigen::internal::predux_mul ( const Packet &  a )

inline

{ return a; }

Referenced by Eigen::internal::scalar_product_op< LhsScalar, RhsScalar >::predux(), predux_mul< Packet4cf >(), and predux_mul< Packet4f >().

Here is the caller graph for this function:

predux_mul< Packet16f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_mul< Packet16f >

(

const Packet16f &

a

)

                                                                    {
//#ifdef EIGEN_VECTORIZE_AVX512DQ
#if 0
  Packet8f lane0 = _mm512_extractf32x8_ps(a, 0);
  Packet8f lane1 = _mm512_extractf32x8_ps(a, 1);
  Packet8f res = pmul(lane0, lane1);
  res = pmul(res, _mm256_permute2f128_ps(res, res, 1));
  res = pmul(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 3, 2)));
  return pfirst(pmul(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 0, 1))));
#else
  Packet4f lane0 = _mm512_extractf32x4_ps(a, 0);
  Packet4f lane1 = _mm512_extractf32x4_ps(a, 1);
  Packet4f lane2 = _mm512_extractf32x4_ps(a, 2);
  Packet4f lane3 = _mm512_extractf32x4_ps(a, 3);
  Packet4f res = pmul(pmul(lane0, lane1), pmul(lane2, lane3));
  res = pmul(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 3, 2)));
  return pfirst(pmul(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 0, 1))));
#endif
}

References pfirst(), and pmul().

Here is the call graph for this function:

predux_mul< Packet1cd >() [1/2]

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux_mul< Packet1cd >

(

const Packet1cd &

a

)

{
  return pfirst(a);
}

References pfirst().

Here is the call graph for this function:

predux_mul< Packet1cd >() [2/2]

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux_mul< Packet1cd >

(

const Packet1cd &

a

)

{
  return pfirst(a);
}

References pfirst().

Here is the call graph for this function:

predux_mul< Packet2cd >()

template<>

EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux_mul< Packet2cd >

(

const Packet2cd &

a

)

{
  return predux(pmul(Packet1cd(_mm256_extractf128_pd(a.v,0)),
                     Packet1cd(_mm256_extractf128_pd(a.v,1))));
}

References pmul(), and predux().

Here is the call graph for this function:

predux_mul< Packet2cf >() [1/4]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux_mul< Packet2cf >

(

const Packet2cf &

a

)

{
  Packet4f b;
  Packet2cf prod;
  b = vec_sld(a.v, a.v, 8);
  prod = pmul<Packet2cf>(a, Packet2cf(b));
 
  return pfirst<Packet2cf>(prod);
}

References pfirst< Packet2cf >(), and pmul< Packet2cf >().

Here is the call graph for this function:

predux_mul< Packet2cf >() [2/4]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux_mul< Packet2cf >

(

const Packet2cf &

a

)

{
  float32x2_t a1, a2, v1, v2, prod;
  std::complex<float> s;
 
  a1 = vget_low_f32(a.v);
  a2 = vget_high_f32(a.v);
   // Get the real values of a | a1_re | a1_re | a2_re | a2_re |
  v1 = vdup_lane_f32(a1, 0);
  // Get the real values of a | a1_im | a1_im | a2_im | a2_im |
  v2 = vdup_lane_f32(a1, 1);
  // Multiply the real a with b
  v1 = vmul_f32(v1, a2);
  // Multiply the imag a with b
  v2 = vmul_f32(v2, a2);
  // Conjugate v2 
  v2 = vreinterpret_f32_u32(veor_u32(vreinterpret_u32_f32(v2), p2ui_CONJ_XOR()));
  // Swap real/imag elements in v2.
  v2 = vrev64_f32(v2);
  // Add v1, v2
  prod = vadd_f32(v1, v2);
 
  vst1_f32((float *)&s, prod);
 
  return s;
}

References p2ui_CONJ_XOR().

Here is the call graph for this function:

predux_mul< Packet2cf >() [3/4]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux_mul< Packet2cf >

(

const Packet2cf &

a

)

{
  return pfirst(pmul(a, Packet2cf(_mm_movehl_ps(a.v,a.v))));
}

References pfirst(), and pmul().

Here is the call graph for this function:

predux_mul< Packet2cf >() [4/4]

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux_mul< Packet2cf >

(

const Packet2cf &

a

)

{
  std::complex<float> res;
  Packet1cd b = pmul<Packet1cd>(a.cd[0], a.cd[1]);
  vec_st2f(b.v, (float*)&res);
  return res;
}

References pmul< Packet1cd >().

Here is the call graph for this function:

predux_mul< Packet2d >() [1/2]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_mul< Packet2d >

(

const Packet2d &

a

)

{
  return pfirst<Packet2d>(_mm_mul_sd(a, _mm_unpackhi_pd(a,a)));
}

References pfirst< Packet2d >().

Here is the call graph for this function:

predux_mul< Packet2d >() [2/2]

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_mul< Packet2d >

(

const Packet2d &

a

)

{
  return pfirst(pmul(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(a), reinterpret_cast<Packet4i>(a), 8))));
}

References pfirst(), and pmul().

Here is the call graph for this function:

predux_mul< Packet4cf >()

template<>

EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux_mul< Packet4cf >

(

const Packet4cf &

a

)

{
  return predux_mul(pmul(Packet2cf(_mm256_extractf128_ps(a.v, 0)),
                         Packet2cf(_mm256_extractf128_ps(a.v, 1))));
}

References pmul(), and predux_mul().

Here is the call graph for this function:

predux_mul< Packet4d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_mul< Packet4d >

(

const Packet4d &

a

)

{
  Packet4d tmp;
  tmp = _mm256_mul_pd(a, _mm256_permute2f128_pd(a,a,1));
  return pfirst(_mm256_mul_pd(tmp, _mm256_shuffle_pd(tmp,tmp,1)));
}

References pfirst().

Here is the call graph for this function:

predux_mul< Packet4f >() [1/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_mul< Packet4f >

(

const Packet4f &

a

)

{
  Packet4f prod;
  prod = pmul(a, vec_sld(a, a, 8));
  return pfirst(pmul(prod, vec_sld(prod, prod, 4)));
}

References pfirst(), and pmul().

Here is the call graph for this function:

predux_mul< Packet4f >() [2/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_mul< Packet4f >

(

const Packet4f &

a

)

{
  float32x2_t a_lo, a_hi, prod;
 
  // Get a_lo = |a1|a2| and a_hi = |a3|a4|
  a_lo = vget_low_f32(a);
  a_hi = vget_high_f32(a);
  // Get the product of a_lo * a_hi -> |a1*a3|a2*a4|
  prod = vmul_f32(a_lo, a_hi);
  // Multiply prod with its swapped value |a2*a4|a1*a3|
  prod = vmul_f32(prod, vrev64_f32(prod));
 
  return vget_lane_f32(prod, 0);
}

predux_mul< Packet4f >() [3/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_mul< Packet4f >

(

const Packet4f &

a

)

{
  Packet4f tmp = _mm_mul_ps(a, _mm_movehl_ps(a,a));
  return pfirst<Packet4f>(_mm_mul_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
}

References pfirst< Packet4f >().

Here is the call graph for this function:

predux_mul< Packet4f >() [4/4]

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_mul< Packet4f >

(

const Packet4f &

a

)

{
  // Return predux_mul<Packet2d> of the subvectors product
  return static_cast<float>(pfirst(predux_mul(pmul(a.v4f[0], a.v4f[1]))));
}

References pfirst(), pmul(), and predux_mul().

Here is the call graph for this function:

predux_mul< Packet4i >() [1/4]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_mul< Packet4i >

(

const Packet4i &

a

)

{
  EIGEN_ALIGN16 int aux[4];
  pstore(aux, a);
  return aux[0] * aux[1] * aux[2] * aux[3];
}

References EIGEN_ALIGN16, and pstore().

Here is the call graph for this function:

predux_mul< Packet4i >() [2/4]

template<>

EIGEN_STRONG_INLINE int32_t Eigen::internal::predux_mul< Packet4i >

(

const Packet4i &

a

)

{
  int32x2_t a_lo, a_hi, prod;
 
  // Get a_lo = |a1|a2| and a_hi = |a3|a4|
  a_lo = vget_low_s32(a);
  a_hi = vget_high_s32(a);
  // Get the product of a_lo * a_hi -> |a1*a3|a2*a4|
  prod = vmul_s32(a_lo, a_hi);
  // Multiply prod with its swapped value |a2*a4|a1*a3|
  prod = vmul_s32(prod, vrev64_s32(prod));
 
  return vget_lane_s32(prod, 0);
}

predux_mul< Packet4i >() [3/4]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_mul< Packet4i >

(

const Packet4i &

a

)

{
  // after some experiments, it is seems this is the fastest way to implement it
  // for GCC (eg., reusing pmul is very slow !)
  // TODO try to call _mm_mul_epu32 directly
  EIGEN_ALIGN16 int aux[4];
  pstore(aux, a);
  return  (aux[0] * aux[1]) * (aux[2] * aux[3]);;
}

References EIGEN_ALIGN16, and pstore().

Here is the call graph for this function:

predux_mul< Packet4i >() [4/4]

template<>

EIGEN_STRONG_INLINE int Eigen::internal::predux_mul< Packet4i >

(

const Packet4i &

a

)

{
  EIGEN_ALIGN16 int aux[4];
  pstore(aux, a);
  return aux[0] * aux[1] * aux[2] * aux[3];
}

References EIGEN_ALIGN16, and pstore().

Here is the call graph for this function:

predux_mul< Packet8d >()

template<>

EIGEN_STRONG_INLINE double Eigen::internal::predux_mul< Packet8d >

(

const Packet8d &

a

)

                                                                   {
  Packet4d lane0 = _mm512_extractf64x4_pd(a, 0);
  Packet4d lane1 = _mm512_extractf64x4_pd(a, 1);
  Packet4d res = pmul(lane0, lane1);
  res = pmul(res, _mm256_permute2f128_pd(res, res, 1));
  return pfirst(pmul(res, _mm256_shuffle_pd(res, res, 1)));
}

References pfirst(), and pmul().

Here is the call graph for this function:

predux_mul< Packet8f >()

template<>

EIGEN_STRONG_INLINE float Eigen::internal::predux_mul< Packet8f >

(

const Packet8f &

a

)

{
  Packet8f tmp;
  tmp = _mm256_mul_ps(a, _mm256_permute2f128_ps(a,a,1));
  tmp = _mm256_mul_ps(tmp, _mm256_shuffle_ps(tmp,tmp,_MM_SHUFFLE(1,0,3,2)));
  return pfirst(_mm256_mul_ps(tmp, _mm256_shuffle_ps(tmp,tmp,1)));
}

References pfirst().

Here is the call graph for this function:

preduxp()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::preduxp ( const Packet *  vecs )

inline

{ return vecs[0]; }

preduxp< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::preduxp< Packet16f >

(

const Packet16f *

vecs

)

{
  EIGEN_EXTRACT_8f_FROM_16f(vecs[0], vecs0);
  EIGEN_EXTRACT_8f_FROM_16f(vecs[1], vecs1);
  EIGEN_EXTRACT_8f_FROM_16f(vecs[2], vecs2);
  EIGEN_EXTRACT_8f_FROM_16f(vecs[3], vecs3);
  EIGEN_EXTRACT_8f_FROM_16f(vecs[4], vecs4);
  EIGEN_EXTRACT_8f_FROM_16f(vecs[5], vecs5);
  EIGEN_EXTRACT_8f_FROM_16f(vecs[6], vecs6);
  EIGEN_EXTRACT_8f_FROM_16f(vecs[7], vecs7);
  EIGEN_EXTRACT_8f_FROM_16f(vecs[8], vecs8);
  EIGEN_EXTRACT_8f_FROM_16f(vecs[9], vecs9);
  EIGEN_EXTRACT_8f_FROM_16f(vecs[10], vecs10);
  EIGEN_EXTRACT_8f_FROM_16f(vecs[11], vecs11);
  EIGEN_EXTRACT_8f_FROM_16f(vecs[12], vecs12);
  EIGEN_EXTRACT_8f_FROM_16f(vecs[13], vecs13);
  EIGEN_EXTRACT_8f_FROM_16f(vecs[14], vecs14);
  EIGEN_EXTRACT_8f_FROM_16f(vecs[15], vecs15);
 
  __m256 hsum1 = _mm256_hadd_ps(vecs0_0, vecs1_0);
  __m256 hsum2 = _mm256_hadd_ps(vecs2_0, vecs3_0);
  __m256 hsum3 = _mm256_hadd_ps(vecs4_0, vecs5_0);
  __m256 hsum4 = _mm256_hadd_ps(vecs6_0, vecs7_0);
 
  __m256 hsum5 = _mm256_hadd_ps(hsum1, hsum1);
  __m256 hsum6 = _mm256_hadd_ps(hsum2, hsum2);
  __m256 hsum7 = _mm256_hadd_ps(hsum3, hsum3);
  __m256 hsum8 = _mm256_hadd_ps(hsum4, hsum4);
 
  __m256 perm1 = _mm256_permute2f128_ps(hsum5, hsum5, 0x23);
  __m256 perm2 = _mm256_permute2f128_ps(hsum6, hsum6, 0x23);
  __m256 perm3 = _mm256_permute2f128_ps(hsum7, hsum7, 0x23);
  __m256 perm4 = _mm256_permute2f128_ps(hsum8, hsum8, 0x23);
 
  __m256 sum1 = _mm256_add_ps(perm1, hsum5);
  __m256 sum2 = _mm256_add_ps(perm2, hsum6);
  __m256 sum3 = _mm256_add_ps(perm3, hsum7);
  __m256 sum4 = _mm256_add_ps(perm4, hsum8);
 
  __m256 blend1 = _mm256_blend_ps(sum1, sum2, 0xcc);
  __m256 blend2 = _mm256_blend_ps(sum3, sum4, 0xcc);
 
  __m256 final = _mm256_blend_ps(blend1, blend2, 0xf0);
 
  hsum1 = _mm256_hadd_ps(vecs0_1, vecs1_1);
  hsum2 = _mm256_hadd_ps(vecs2_1, vecs3_1);
  hsum3 = _mm256_hadd_ps(vecs4_1, vecs5_1);
  hsum4 = _mm256_hadd_ps(vecs6_1, vecs7_1);
 
  hsum5 = _mm256_hadd_ps(hsum1, hsum1);
  hsum6 = _mm256_hadd_ps(hsum2, hsum2);
  hsum7 = _mm256_hadd_ps(hsum3, hsum3);
  hsum8 = _mm256_hadd_ps(hsum4, hsum4);
 
  perm1 = _mm256_permute2f128_ps(hsum5, hsum5, 0x23);
  perm2 = _mm256_permute2f128_ps(hsum6, hsum6, 0x23);
  perm3 = _mm256_permute2f128_ps(hsum7, hsum7, 0x23);
  perm4 = _mm256_permute2f128_ps(hsum8, hsum8, 0x23);
 
  sum1 = _mm256_add_ps(perm1, hsum5);
  sum2 = _mm256_add_ps(perm2, hsum6);
  sum3 = _mm256_add_ps(perm3, hsum7);
  sum4 = _mm256_add_ps(perm4, hsum8);
 
  blend1 = _mm256_blend_ps(sum1, sum2, 0xcc);
  blend2 = _mm256_blend_ps(sum3, sum4, 0xcc);
 
  final = padd(final, _mm256_blend_ps(blend1, blend2, 0xf0));
 
  hsum1 = _mm256_hadd_ps(vecs8_0, vecs9_0);
  hsum2 = _mm256_hadd_ps(vecs10_0, vecs11_0);
  hsum3 = _mm256_hadd_ps(vecs12_0, vecs13_0);
  hsum4 = _mm256_hadd_ps(vecs14_0, vecs15_0);
 
  hsum5 = _mm256_hadd_ps(hsum1, hsum1);
  hsum6 = _mm256_hadd_ps(hsum2, hsum2);
  hsum7 = _mm256_hadd_ps(hsum3, hsum3);
  hsum8 = _mm256_hadd_ps(hsum4, hsum4);
 
  perm1 = _mm256_permute2f128_ps(hsum5, hsum5, 0x23);
  perm2 = _mm256_permute2f128_ps(hsum6, hsum6, 0x23);
  perm3 = _mm256_permute2f128_ps(hsum7, hsum7, 0x23);
  perm4 = _mm256_permute2f128_ps(hsum8, hsum8, 0x23);
 
  sum1 = _mm256_add_ps(perm1, hsum5);
  sum2 = _mm256_add_ps(perm2, hsum6);
  sum3 = _mm256_add_ps(perm3, hsum7);
  sum4 = _mm256_add_ps(perm4, hsum8);
 
  blend1 = _mm256_blend_ps(sum1, sum2, 0xcc);
  blend2 = _mm256_blend_ps(sum3, sum4, 0xcc);
 
  __m256 final_1 = _mm256_blend_ps(blend1, blend2, 0xf0);
 
  hsum1 = _mm256_hadd_ps(vecs8_1, vecs9_1);
  hsum2 = _mm256_hadd_ps(vecs10_1, vecs11_1);
  hsum3 = _mm256_hadd_ps(vecs12_1, vecs13_1);
  hsum4 = _mm256_hadd_ps(vecs14_1, vecs15_1);
 
  hsum5 = _mm256_hadd_ps(hsum1, hsum1);
  hsum6 = _mm256_hadd_ps(hsum2, hsum2);
  hsum7 = _mm256_hadd_ps(hsum3, hsum3);
  hsum8 = _mm256_hadd_ps(hsum4, hsum4);
 
  perm1 = _mm256_permute2f128_ps(hsum5, hsum5, 0x23);
  perm2 = _mm256_permute2f128_ps(hsum6, hsum6, 0x23);
  perm3 = _mm256_permute2f128_ps(hsum7, hsum7, 0x23);
  perm4 = _mm256_permute2f128_ps(hsum8, hsum8, 0x23);
 
  sum1 = _mm256_add_ps(perm1, hsum5);
  sum2 = _mm256_add_ps(perm2, hsum6);
  sum3 = _mm256_add_ps(perm3, hsum7);
  sum4 = _mm256_add_ps(perm4, hsum8);
 
  blend1 = _mm256_blend_ps(sum1, sum2, 0xcc);
  blend2 = _mm256_blend_ps(sum3, sum4, 0xcc);
 
  final_1 = padd(final_1, _mm256_blend_ps(blend1, blend2, 0xf0));
 
  __m512 final_output;
 
  EIGEN_INSERT_8f_INTO_16f(final_output, final, final_1);
  return final_output;
}

References EIGEN_EXTRACT_8f_FROM_16f, EIGEN_INSERT_8f_INTO_16f, and padd().

Here is the call graph for this function:

preduxp< Packet1cd >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::preduxp< Packet1cd >

(

const Packet1cd *

vecs

)

{
  return vecs[0];
}

preduxp< Packet1cd >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::preduxp< Packet1cd >

(

const Packet1cd *

vecs

)

{
  return vecs[0];
}

preduxp< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::preduxp< Packet2cd >

(

const Packet2cd *

vecs

)

{
  Packet4d t0 = _mm256_permute2f128_pd(vecs[0].v,vecs[1].v, 0 + (2<<4));
  Packet4d t1 = _mm256_permute2f128_pd(vecs[0].v,vecs[1].v, 1 + (3<<4));
 
  return Packet2cd(_mm256_add_pd(t0,t1));
}

preduxp< Packet2cf >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::preduxp< Packet2cf >

(

const Packet2cf *

vecs

)

{
  Packet4f b1, b2;
#ifdef _BIG_ENDIAN  
  b1 = vec_sld(vecs[0].v, vecs[1].v, 8);
  b2 = vec_sld(vecs[1].v, vecs[0].v, 8);
#else
  b1 = vec_sld(vecs[1].v, vecs[0].v, 8);
  b2 = vec_sld(vecs[0].v, vecs[1].v, 8);
#endif
  b2 = vec_sld(b2, b2, 8);
  b2 = padd<Packet4f>(b1, b2);
 
  return Packet2cf(b2);
}

References padd< Packet4f >().

Here is the call graph for this function:

preduxp< Packet2cf >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::preduxp< Packet2cf >

(

const Packet2cf *

vecs

)

{
  Packet4f sum1, sum2, sum;
 
  // Add the first two 64-bit float32x2_t of vecs[0]
  sum1 = vcombine_f32(vget_low_f32(vecs[0].v), vget_low_f32(vecs[1].v));
  sum2 = vcombine_f32(vget_high_f32(vecs[0].v), vget_high_f32(vecs[1].v));
  sum = vaddq_f32(sum1, sum2);
 
  return Packet2cf(sum);
}

preduxp< Packet2cf >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::preduxp< Packet2cf >

(

const Packet2cf *

vecs

)

{
  return Packet2cf(_mm_add_ps(_mm_movelh_ps(vecs[0].v,vecs[1].v), _mm_movehl_ps(vecs[1].v,vecs[0].v)));
}

preduxp< Packet2cf >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::preduxp< Packet2cf >

(

const Packet2cf *

vecs

)

{
  PacketBlock<Packet2cf,2> transpose;
  transpose.packet[0] = vecs[0];
  transpose.packet[1] = vecs[1];
  ptranspose(transpose);
 
  return padd<Packet2cf>(transpose.packet[0], transpose.packet[1]);
} 

References Eigen::internal::PacketBlock< Packet, N >::packet, padd< Packet2cf >(), and ptranspose().

Here is the call graph for this function:

preduxp< Packet2d >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::preduxp< Packet2d >

(

const Packet2d *

vecs

)

{
  return _mm_add_pd(_mm_unpacklo_pd(vecs[0], vecs[1]), _mm_unpackhi_pd(vecs[0], vecs[1]));
}

preduxp< Packet2d >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::preduxp< Packet2d >

(

const Packet2d *

vecs

)

{
  Packet2d v[2], sum;
  v[0] = padd<Packet2d>(vecs[0], reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(vecs[0]), reinterpret_cast<Packet4ui>(vecs[0]), 8)));
  v[1] = padd<Packet2d>(vecs[1], reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(vecs[1]), reinterpret_cast<Packet4ui>(vecs[1]), 8)));
 
  sum = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(v[0]), reinterpret_cast<Packet4ui>(v[1]), 8));
 
  return sum;
}

References padd< Packet2d >().

Here is the call graph for this function:

preduxp< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::preduxp< Packet4cf >

(

const Packet4cf *

vecs

)

{
  Packet8f t0 = _mm256_shuffle_ps(vecs[0].v, vecs[0].v, _MM_SHUFFLE(3, 1, 2 ,0));
  Packet8f t1 = _mm256_shuffle_ps(vecs[1].v, vecs[1].v, _MM_SHUFFLE(3, 1, 2 ,0));
  t0 = _mm256_hadd_ps(t0,t1);
  Packet8f t2 = _mm256_shuffle_ps(vecs[2].v, vecs[2].v, _MM_SHUFFLE(3, 1, 2 ,0));
  Packet8f t3 = _mm256_shuffle_ps(vecs[3].v, vecs[3].v, _MM_SHUFFLE(3, 1, 2 ,0));
  t2 = _mm256_hadd_ps(t2,t3);
  
  t1 = _mm256_permute2f128_ps(t0,t2, 0 + (2<<4));
  t3 = _mm256_permute2f128_ps(t0,t2, 1 + (3<<4));
 
  return Packet4cf(_mm256_add_ps(t1,t3));
}

preduxp< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::preduxp< Packet4d >

(

const Packet4d *

vecs

)

{
 Packet4d tmp0, tmp1;
 
  tmp0 = _mm256_hadd_pd(vecs[0], vecs[1]);
  tmp0 = _mm256_add_pd(tmp0, _mm256_permute2f128_pd(tmp0, tmp0, 1));
 
  tmp1 = _mm256_hadd_pd(vecs[2], vecs[3]);
  tmp1 = _mm256_add_pd(tmp1, _mm256_permute2f128_pd(tmp1, tmp1, 1));
 
  return _mm256_blend_pd(tmp0, tmp1, 0xC);
}

preduxp< Packet4f >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::preduxp< Packet4f >

(

const Packet4f *

vecs

)

{
  Packet4f v[4], sum[4];
 
  // It's easier and faster to transpose then add as columns
  // Check: http://www.freevec.org/function/matrix_4x4_transpose_floats for explanation
  // Do the transpose, first set of moves
  v[0] = vec_mergeh(vecs[0], vecs[2]);
  v[1] = vec_mergel(vecs[0], vecs[2]);
  v[2] = vec_mergeh(vecs[1], vecs[3]);
  v[3] = vec_mergel(vecs[1], vecs[3]);
  // Get the resulting vectors
  sum[0] = vec_mergeh(v[0], v[2]);
  sum[1] = vec_mergel(v[0], v[2]);
  sum[2] = vec_mergeh(v[1], v[3]);
  sum[3] = vec_mergel(v[1], v[3]);
 
  // Now do the summation:
  // Lines 0+1
  sum[0] = sum[0] + sum[1];
  // Lines 2+3
  sum[1] = sum[2] + sum[3];
  // Add the results
  sum[0] = sum[0] + sum[1];
 
  return sum[0];
}

preduxp< Packet4f >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::preduxp< Packet4f >

(

const Packet4f *

vecs

)

{
  float32x4x2_t vtrn1, vtrn2, res1, res2;
  Packet4f sum1, sum2, sum;
 
  // NEON zip performs interleaving of the supplied vectors.
  // We perform two interleaves in a row to acquire the transposed vector
  vtrn1 = vzipq_f32(vecs[0], vecs[2]);
  vtrn2 = vzipq_f32(vecs[1], vecs[3]);
  res1 = vzipq_f32(vtrn1.val[0], vtrn2.val[0]);
  res2 = vzipq_f32(vtrn1.val[1], vtrn2.val[1]);
 
  // Do the addition of the resulting vectors
  sum1 = vaddq_f32(res1.val[0], res1.val[1]);
  sum2 = vaddq_f32(res2.val[0], res2.val[1]);
  sum = vaddq_f32(sum1, sum2);
 
  return sum;
}

preduxp< Packet4f >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::preduxp< Packet4f >

(

const Packet4f *

vecs

)

{
  Packet4f tmp0, tmp1, tmp2;
  tmp0 = _mm_unpacklo_ps(vecs[0], vecs[1]);
  tmp1 = _mm_unpackhi_ps(vecs[0], vecs[1]);
  tmp2 = _mm_unpackhi_ps(vecs[2], vecs[3]);
  tmp0 = _mm_add_ps(tmp0, tmp1);
  tmp1 = _mm_unpacklo_ps(vecs[2], vecs[3]);
  tmp1 = _mm_add_ps(tmp1, tmp2);
  tmp2 = _mm_movehl_ps(tmp1, tmp0);
  tmp0 = _mm_movelh_ps(tmp0, tmp1);
  return _mm_add_ps(tmp0, tmp2);
}

preduxp< Packet4f >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::preduxp< Packet4f >

(

const Packet4f *

vecs

)

{
  PacketBlock<Packet4f,4> transpose;
  transpose.packet[0] = vecs[0];
  transpose.packet[1] = vecs[1];
  transpose.packet[2] = vecs[2];
  transpose.packet[3] = vecs[3];
  ptranspose(transpose);
 
  Packet4f sum = padd(transpose.packet[0], transpose.packet[1]);
  sum = padd(sum, transpose.packet[2]);
  sum = padd(sum, transpose.packet[3]);
  return sum;
}

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

Here is the call graph for this function:

preduxp< Packet4i >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preduxp< Packet4i >

(

const Packet4i *

vecs

)

{
  Packet4i v[4], sum[4];
 
  // It's easier and faster to transpose then add as columns
  // Check: http://www.freevec.org/function/matrix_4x4_transpose_floats for explanation
  // Do the transpose, first set of moves
  v[0] = vec_mergeh(vecs[0], vecs[2]);
  v[1] = vec_mergel(vecs[0], vecs[2]);
  v[2] = vec_mergeh(vecs[1], vecs[3]);
  v[3] = vec_mergel(vecs[1], vecs[3]);
  // Get the resulting vectors
  sum[0] = vec_mergeh(v[0], v[2]);
  sum[1] = vec_mergel(v[0], v[2]);
  sum[2] = vec_mergeh(v[1], v[3]);
  sum[3] = vec_mergel(v[1], v[3]);
 
  // Now do the summation:
  // Lines 0+1
  sum[0] = sum[0] + sum[1];
  // Lines 2+3
  sum[1] = sum[2] + sum[3];
  // Add the results
  sum[0] = sum[0] + sum[1];
 
  return sum[0];
}

preduxp< Packet4i >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preduxp< Packet4i >

(

const Packet4i *

vecs

)

{
  int32x4x2_t vtrn1, vtrn2, res1, res2;
  Packet4i sum1, sum2, sum;
 
  // NEON zip performs interleaving of the supplied vectors.
  // We perform two interleaves in a row to acquire the transposed vector
  vtrn1 = vzipq_s32(vecs[0], vecs[2]);
  vtrn2 = vzipq_s32(vecs[1], vecs[3]);
  res1 = vzipq_s32(vtrn1.val[0], vtrn2.val[0]);
  res2 = vzipq_s32(vtrn1.val[1], vtrn2.val[1]);
 
  // Do the addition of the resulting vectors
  sum1 = vaddq_s32(res1.val[0], res1.val[1]);
  sum2 = vaddq_s32(res2.val[0], res2.val[1]);
  sum = vaddq_s32(sum1, sum2);
 
  return sum;
}

preduxp< Packet4i >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preduxp< Packet4i >

(

const Packet4i *

vecs

)

{
  Packet4i tmp0, tmp1, tmp2;
  tmp0 = _mm_unpacklo_epi32(vecs[0], vecs[1]);
  tmp1 = _mm_unpackhi_epi32(vecs[0], vecs[1]);
  tmp2 = _mm_unpackhi_epi32(vecs[2], vecs[3]);
  tmp0 = _mm_add_epi32(tmp0, tmp1);
  tmp1 = _mm_unpacklo_epi32(vecs[2], vecs[3]);
  tmp1 = _mm_add_epi32(tmp1, tmp2);
  tmp2 = _mm_unpacklo_epi64(tmp0, tmp1);
  tmp0 = _mm_unpackhi_epi64(tmp0, tmp1);
  return _mm_add_epi32(tmp0, tmp2);
}

preduxp< Packet4i >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preduxp< Packet4i >

(

const Packet4i *

vecs

)

{
  Packet4i v[4], sum[4];
 
  // It's easier and faster to transpose then add as columns
  // Check: http://www.freevec.org/function/matrix_4x4_transpose_floats for explanation
  // Do the transpose, first set of moves
  v[0] = vec_mergeh(vecs[0], vecs[2]);
  v[1] = vec_mergel(vecs[0], vecs[2]);
  v[2] = vec_mergeh(vecs[1], vecs[3]);
  v[3] = vec_mergel(vecs[1], vecs[3]);
  // Get the resulting vectors
  sum[0] = vec_mergeh(v[0], v[2]);
  sum[1] = vec_mergel(v[0], v[2]);
  sum[2] = vec_mergeh(v[1], v[3]);
  sum[3] = vec_mergel(v[1], v[3]);
 
  // Now do the summation:
  // Lines 0+1
  sum[0] = padd<Packet4i>(sum[0], sum[1]);
  // Lines 2+3
  sum[1] = padd<Packet4i>(sum[2], sum[3]);
  // Add the results
  sum[0] = padd<Packet4i>(sum[0], sum[1]);
 
  return sum[0];
}

References padd< Packet4i >().

Here is the call graph for this function:

preduxp< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::preduxp< Packet8d >

(

const Packet8d *

vecs

)

{
  Packet4d vecs0_0 = _mm512_extractf64x4_pd(vecs[0], 0);
  Packet4d vecs0_1 = _mm512_extractf64x4_pd(vecs[0], 1);
 
  Packet4d vecs1_0 = _mm512_extractf64x4_pd(vecs[1], 0);
  Packet4d vecs1_1 = _mm512_extractf64x4_pd(vecs[1], 1);
 
  Packet4d vecs2_0 = _mm512_extractf64x4_pd(vecs[2], 0);
  Packet4d vecs2_1 = _mm512_extractf64x4_pd(vecs[2], 1);
 
  Packet4d vecs3_0 = _mm512_extractf64x4_pd(vecs[3], 0);
  Packet4d vecs3_1 = _mm512_extractf64x4_pd(vecs[3], 1);
 
  Packet4d vecs4_0 = _mm512_extractf64x4_pd(vecs[4], 0);
  Packet4d vecs4_1 = _mm512_extractf64x4_pd(vecs[4], 1);
 
  Packet4d vecs5_0 = _mm512_extractf64x4_pd(vecs[5], 0);
  Packet4d vecs5_1 = _mm512_extractf64x4_pd(vecs[5], 1);
 
  Packet4d vecs6_0 = _mm512_extractf64x4_pd(vecs[6], 0);
  Packet4d vecs6_1 = _mm512_extractf64x4_pd(vecs[6], 1);
 
  Packet4d vecs7_0 = _mm512_extractf64x4_pd(vecs[7], 0);
  Packet4d vecs7_1 = _mm512_extractf64x4_pd(vecs[7], 1);
 
  Packet4d tmp0, tmp1;
 
  tmp0 = _mm256_hadd_pd(vecs0_0, vecs1_0);
  tmp0 = _mm256_add_pd(tmp0, _mm256_permute2f128_pd(tmp0, tmp0, 1));
 
  tmp1 = _mm256_hadd_pd(vecs2_0, vecs3_0);
  tmp1 = _mm256_add_pd(tmp1, _mm256_permute2f128_pd(tmp1, tmp1, 1));
 
  __m256d final_0 = _mm256_blend_pd(tmp0, tmp1, 0xC);
 
  tmp0 = _mm256_hadd_pd(vecs0_1, vecs1_1);
  tmp0 = _mm256_add_pd(tmp0, _mm256_permute2f128_pd(tmp0, tmp0, 1));
 
  tmp1 = _mm256_hadd_pd(vecs2_1, vecs3_1);
  tmp1 = _mm256_add_pd(tmp1, _mm256_permute2f128_pd(tmp1, tmp1, 1));
 
  final_0 = padd(final_0, _mm256_blend_pd(tmp0, tmp1, 0xC));
 
  tmp0 = _mm256_hadd_pd(vecs4_0, vecs5_0);
  tmp0 = _mm256_add_pd(tmp0, _mm256_permute2f128_pd(tmp0, tmp0, 1));
 
  tmp1 = _mm256_hadd_pd(vecs6_0, vecs7_0);
  tmp1 = _mm256_add_pd(tmp1, _mm256_permute2f128_pd(tmp1, tmp1, 1));
 
  __m256d final_1 = _mm256_blend_pd(tmp0, tmp1, 0xC);
 
  tmp0 = _mm256_hadd_pd(vecs4_1, vecs5_1);
  tmp0 = _mm256_add_pd(tmp0, _mm256_permute2f128_pd(tmp0, tmp0, 1));
 
  tmp1 = _mm256_hadd_pd(vecs6_1, vecs7_1);
  tmp1 = _mm256_add_pd(tmp1, _mm256_permute2f128_pd(tmp1, tmp1, 1));
 
  final_1 = padd(final_1, _mm256_blend_pd(tmp0, tmp1, 0xC));
 
  __m512d final_output = _mm512_insertf64x4(final_output, final_0, 0);
 
  return _mm512_insertf64x4(final_output, final_1, 1);
}

References padd().

Here is the call graph for this function:

preduxp< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::preduxp< Packet8f >

(

const Packet8f *

vecs

)

{
    __m256 hsum1 = _mm256_hadd_ps(vecs[0], vecs[1]);
    __m256 hsum2 = _mm256_hadd_ps(vecs[2], vecs[3]);
    __m256 hsum3 = _mm256_hadd_ps(vecs[4], vecs[5]);
    __m256 hsum4 = _mm256_hadd_ps(vecs[6], vecs[7]);
 
    __m256 hsum5 = _mm256_hadd_ps(hsum1, hsum1);
    __m256 hsum6 = _mm256_hadd_ps(hsum2, hsum2);
    __m256 hsum7 = _mm256_hadd_ps(hsum3, hsum3);
    __m256 hsum8 = _mm256_hadd_ps(hsum4, hsum4);
 
    __m256 perm1 =  _mm256_permute2f128_ps(hsum5, hsum5, 0x23);
    __m256 perm2 =  _mm256_permute2f128_ps(hsum6, hsum6, 0x23);
    __m256 perm3 =  _mm256_permute2f128_ps(hsum7, hsum7, 0x23);
    __m256 perm4 =  _mm256_permute2f128_ps(hsum8, hsum8, 0x23);
 
    __m256 sum1 = _mm256_add_ps(perm1, hsum5);
    __m256 sum2 = _mm256_add_ps(perm2, hsum6);
    __m256 sum3 = _mm256_add_ps(perm3, hsum7);
    __m256 sum4 = _mm256_add_ps(perm4, hsum8);
 
    __m256 blend1 = _mm256_blend_ps(sum1, sum2, 0xcc);
    __m256 blend2 = _mm256_blend_ps(sum3, sum4, 0xcc);
 
    __m256 final = _mm256_blend_ps(blend1, blend2, 0xf0);
    return final;
}

prefetch()

template<typename Scalar >

EIGEN_DEVICE_FUNC void Eigen::internal::prefetch ( const Scalar *  addr )

inline

{
#ifdef __CUDA_ARCH__
#if defined(__LP64__)
  // 64-bit pointer operand constraint for inlined asm
  asm(" prefetch.L1 [ %1 ];" : "=l"(addr) : "l"(addr));
#else
  // 32-bit pointer operand constraint for inlined asm
  asm(" prefetch.L1 [ %1 ];" : "=r"(addr) : "r"(addr));
#endif
#elif (!EIGEN_COMP_MSVC) && (EIGEN_COMP_GNUC || EIGEN_COMP_CLANG || EIGEN_COMP_ICC)
  __builtin_prefetch(addr);
#endif
}

Referenced by Eigen::internal::gebp_kernel< LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >::operator()(), Eigen::internal::BlasLinearMapper< Scalar, Index, AlignmentType >::prefetch(), and sparselu_gemm().

Here is the caller graph for this function:

prefetch< double >() [1/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< double >

(

const double *

addr

)

{ _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }

prefetch< double >() [2/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< double >

(

const double *

addr

)

{ _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }

prefetch< double >() [3/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< double >

(

const double *

addr

)

{ _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }

prefetch< double >() [4/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< double >

(

const double *

addr

)

{ EIGEN_ZVECTOR_PREFETCH(addr); }

References EIGEN_ZVECTOR_PREFETCH.

prefetch< float >() [1/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< float >

(

const float *

addr

)

{ EIGEN_PPC_PREFETCH(addr); }

References EIGEN_PPC_PREFETCH.

prefetch< float >() [2/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< float >

(

const float *

addr

)

{ _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }

prefetch< float >() [3/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< float >

(

const float *

addr

)

{ _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }

prefetch< float >() [4/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< float >

(

const float *

addr

)

{ EIGEN_ARM_PREFETCH(addr); }

References EIGEN_ARM_PREFETCH.

prefetch< float >() [5/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< float >

(

const float *

addr

)

{ _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }

prefetch< float >() [6/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< float >

(

const float *

addr

)

{ EIGEN_ZVECTOR_PREFETCH(addr); }

References EIGEN_ZVECTOR_PREFETCH.

prefetch< int >() [1/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int >

(

const int *

addr

)

{ EIGEN_PPC_PREFETCH(addr); }

References EIGEN_PPC_PREFETCH.

prefetch< int >() [2/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int >

(

const int *

addr

)

{ _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }

prefetch< int >() [3/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int >

(

const int *

addr

)

{ _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }

prefetch< int >() [4/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int >

(

const int *

addr

)

{ _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }

prefetch< int >() [5/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int >

(

const int *

addr

)

{ EIGEN_ZVECTOR_PREFETCH(addr); }

References EIGEN_ZVECTOR_PREFETCH.

prefetch< int32_t >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int32_t >

(

const int32_t *

addr

)

{ EIGEN_ARM_PREFETCH(addr); }

References EIGEN_ARM_PREFETCH.

prefetch< std::complex< double > >() [1/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< std::complex< double > >

(

const std::complex< double > *

addr

)

{ _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }

prefetch< std::complex< double > >() [2/2]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< std::complex< double > >

(

const std::complex< double > *

addr

)

{ EIGEN_ZVECTOR_PREFETCH(addr); }

References EIGEN_ZVECTOR_PREFETCH.

prefetch< std::complex< float > >() [1/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< std::complex< float > >

(

const std::complex< float > *

addr

)

{ EIGEN_PPC_PREFETCH(addr); }

References EIGEN_PPC_PREFETCH.

prefetch< std::complex< float > >() [2/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< std::complex< float > >

(

const std::complex< float > *

addr

)

{ EIGEN_ARM_PREFETCH((const float *)addr); }

References EIGEN_ARM_PREFETCH.

prefetch< std::complex< float > >() [3/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< std::complex< float > >

(

const std::complex< float > *

addr

)

{ _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }

prefetch< std::complex< float > >() [4/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::prefetch< std::complex< float > >

(

const std::complex< float > *

addr

)

{ EIGEN_ZVECTOR_PREFETCH(addr); }

References EIGEN_ZVECTOR_PREFETCH.

preverse() [1/23]

template<typename Packet >

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

inline

{ return a; }

preverse() [2/23]

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::preverse

(

const Packet16f &

a

)

{
  return _mm512_permutexvar_ps(_mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15), a);
}

preverse() [3/23]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::preverse

(

const Packet1cd &

a

)

{ return a; }

preverse() [4/23]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::preverse

(

const Packet1cd &

a

)

{ return a; }

preverse() [5/23]

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::preverse

(

const Packet2cd &

a

)

                                                                      {
  __m256d result = _mm256_permute2f128_pd(a.v, a.v, 1);
  return Packet2cd(result);
}

preverse() [6/23]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::preverse

(

const Packet2cf &

a

)

{
  Packet4f rev_a;
  rev_a = vec_perm(a.v, a.v, p16uc_COMPLEX32_REV2);
  return Packet2cf(rev_a);
}

References p16uc_COMPLEX32_REV2.

Referenced by Eigen::internal::unary_evaluator< Reverse< ArgType, Direction > >::packet(), pcplxflip(), preverse(), Eigen::internal::reverse_packet_cond< PacketType, ReversePacket >::run(), Eigen::internal::quat_product< Architecture::SSE, Derived, OtherDerived, double >::run(), and Eigen::internal::unary_evaluator< Reverse< ArgType, Direction > >::writePacket().

Here is the caller graph for this function:

preverse() [7/23]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::preverse

(

const Packet2cf &

a

)

{
  float32x2_t a_lo, a_hi;
  Packet4f a_r128;
 
  a_lo = vget_low_f32(a.v);
  a_hi = vget_high_f32(a.v);
  a_r128 = vcombine_f32(a_hi, a_lo);
 
  return Packet2cf(a_r128);
}

preverse() [8/23]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::preverse

(

const Packet2cf &

a

)

{ return Packet2cf(_mm_castpd_ps(preverse(Packet2d(_mm_castps_pd(a.v))))); }

References preverse().

Here is the call graph for this function:

preverse() [9/23]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::preverse

(

const Packet2cf &

a

)

{
  Packet2cf res;
  res.cd[0] = a.cd[1];
  res.cd[1] = a.cd[0];
  return res;
}

preverse() [10/23]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::preverse

(

const Packet2d &

a

)

{ return _mm_shuffle_pd(a,a,0x1); }

preverse() [11/23]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::preverse

(

const Packet2d &

a

)

{
  return reinterpret_cast<Packet2d>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE64));
}

References p16uc_REVERSE64.

preverse() [12/23]

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::preverse

(

const Packet4cf &

a

)

                                                                      {
  __m128 low  = _mm256_extractf128_ps(a.v, 0);
  __m128 high = _mm256_extractf128_ps(a.v, 1);
  __m128d lowd  = _mm_castps_pd(low);
  __m128d highd = _mm_castps_pd(high);
  low  = _mm_castpd_ps(_mm_shuffle_pd(lowd,lowd,0x1));
  high = _mm_castpd_ps(_mm_shuffle_pd(highd,highd,0x1));
  __m256 result = _mm256_setzero_ps();
  result = _mm256_insertf128_ps(result, low, 1);
  result = _mm256_insertf128_ps(result, high, 0);
  return Packet4cf(result);
}

preverse() [13/23]

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::preverse

(

const Packet4d &

a

)

{
   __m256d tmp = _mm256_shuffle_pd(a,a,5);
  return _mm256_permute2f128_pd(tmp, tmp, 1);
  #if 0
  // This version is unlikely to be faster as _mm256_shuffle_ps and _mm256_permute_pd
  // exhibit the same latency/throughput, but it is here for future reference/benchmarking...
  __m256d swap_halves = _mm256_permute2f128_pd(a,a,1);
    return _mm256_permute_pd(swap_halves,5);
  #endif
}

preverse() [14/23]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::preverse

(

const Packet4f &

a

)

{
  return reinterpret_cast<Packet4f>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE32));
}

References p16uc_REVERSE32.

preverse() [15/23]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::preverse

(

const Packet4f &

a

)

                                                                    {
  float32x2_t a_lo, a_hi;
  Packet4f a_r64;
 
  a_r64 = vrev64q_f32(a);
  a_lo = vget_low_f32(a_r64);
  a_hi = vget_high_f32(a_r64);
  return vcombine_f32(a_hi, a_lo);
}

preverse() [16/23]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::preverse

(

const Packet4f &

a

)

{ return _mm_shuffle_ps(a,a,0x1B); }

preverse() [17/23]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::preverse

(

const Packet4f &

a

)

{
  Packet4f rev;
  rev.v4f[0] = preverse<Packet2d>(a.v4f[1]);
  rev.v4f[1] = preverse<Packet2d>(a.v4f[0]);
  return rev;
}

References Eigen::internal::Packet4f::v4f.

preverse() [18/23]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preverse

(

const Packet4i &

a

)

{
  return reinterpret_cast<Packet4i>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE32)); }

References p16uc_REVERSE32.

preverse() [19/23]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preverse

(

const Packet4i &

a

)

                                                                    {
  int32x2_t a_lo, a_hi;
  Packet4i a_r64;
 
  a_r64 = vrev64q_s32(a);
  a_lo = vget_low_s32(a_r64);
  a_hi = vget_high_s32(a_r64);
  return vcombine_s32(a_hi, a_lo);
}

preverse() [20/23]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preverse

(

const Packet4i &

a

)

{ return _mm_shuffle_epi32(a,0x1B); }

preverse() [21/23]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::preverse

(

const Packet4i &

a

)

{
  return reinterpret_cast<Packet4i>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE32));
}

References p16uc_REVERSE32.

preverse() [22/23]

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::preverse

(

const Packet8d &

a

)

{
  return _mm512_permutexvar_pd(_mm512_set_epi32(0, 0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7), a);
}

preverse() [23/23]

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::preverse

(

const Packet8f &

a

)

{
  __m256 tmp = _mm256_shuffle_ps(a,a,0x1b);
  return _mm256_permute2f128_ps(tmp, tmp, 1);
}

print_matrix()

template<typename Derived >

std::ostream & Eigen::internal::print_matrix	(	std::ostream &	s,
		const Derived &	_m,
		const IOFormat &	fmt
	)

{
  if(_m.size() == 0)
  {
    s << fmt.matPrefix << fmt.matSuffix;
    return s;
  }
  
  typename Derived::Nested m = _m;
  typedef typename Derived::Scalar Scalar;
 
  Index width = 0;
 
  std::streamsize explicit_precision;
  if(fmt.precision == StreamPrecision)
  {
    explicit_precision = 0;
  }
  else if(fmt.precision == FullPrecision)
  {
    if (NumTraits<Scalar>::IsInteger)
    {
      explicit_precision = 0;
    }
    else
    {
      explicit_precision = significant_decimals_impl<Scalar>::run();
    }
  }
  else
  {
    explicit_precision = fmt.precision;
  }
 
  std::streamsize old_precision = 0;
  if(explicit_precision) old_precision = s.precision(explicit_precision);
 
  bool align_cols = !(fmt.flags & DontAlignCols);
  if(align_cols)
  {
    // compute the largest width
    for(Index j = 0; j < m.cols(); ++j)
      for(Index i = 0; i < m.rows(); ++i)
      {
        std::stringstream sstr;
        sstr.copyfmt(s);
        sstr << m.coeff(i,j);
        width = std::max<Index>(width, Index(sstr.str().length()));
      }
  }
  s << fmt.matPrefix;
  for(Index i = 0; i < m.rows(); ++i)
  {
    if (i)
      s << fmt.rowSpacer;
    s << fmt.rowPrefix;
    if(width) s.width(width);
    s << m.coeff(i, 0);
    for(Index j = 1; j < m.cols(); ++j)
    {
      s << fmt.coeffSeparator;
      if (width) s.width(width);
      s << m.coeff(i, j);
    }
    s << fmt.rowSuffix;
    if( i < m.rows() - 1)
      s << fmt.rowSeparator;
  }
  s << fmt.matSuffix;
  if(explicit_precision) s.precision(old_precision);
  return s;
}

References Eigen::IOFormat::coeffSeparator, Eigen::DontAlignCols, Eigen::IOFormat::flags, Eigen::FullPrecision, Eigen::IOFormat::matPrefix, Eigen::IOFormat::matSuffix, Eigen::IOFormat::precision, Eigen::IOFormat::rowPrefix, Eigen::IOFormat::rowSeparator, Eigen::IOFormat::rowSpacer, Eigen::IOFormat::rowSuffix, Eigen::internal::significant_decimals_impl< Scalar >::run(), and Eigen::StreamPrecision.

Referenced by Eigen::DenseBase< Derived >::operator<<().

Here is the call graph for this function:

Here is the caller graph for this function:

pround()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pround

(

const Packet &

a

)

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

References round().

Here is the call graph for this function:

pround< Packet2d >()

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pround< Packet2d >

(

const Packet2d &

a

)

{ return vec_round(a); }

pround< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pround< Packet4d >

(

const Packet4d &

a

)

{ return _mm256_round_pd(a, _MM_FROUND_CUR_DIRECTION); }

pround< Packet4f >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pround< Packet4f >

(

const Packet4f &

a

)

{ return vec_round(a); }

pround< Packet4f >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pround< Packet4f >

(

const Packet4f &

a

)

{
  Packet4f res;
  res.v4f[0] = vec_round(a.v4f[0]);
  res.v4f[1] = vec_round(a.v4f[1]);
  return res;
}

References Eigen::internal::Packet4f::v4f.

pround< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pround< Packet8f >

(

const Packet8f &

a

)

{ return _mm256_round_ps(a, _MM_FROUND_CUR_DIRECTION); }

prsqrt()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::prsqrt

(

const Packet &

a

)

                               {
  return pdiv(pset1<Packet>(1), psqrt(a));
}

References pdiv(), and psqrt().

Here is the call graph for this function:

prsqrt< Packet2d >() [1/2]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d Eigen::internal::prsqrt< Packet2d >

(

const Packet2d &

x

)

                                             {
  // Unfortunately we can't use the much faster mm_rqsrt_pd since it only provides an approximation.
  return _mm_div_pd(pset1<Packet2d>(1.0), _mm_sqrt_pd(x));
}

References pset1< Packet2d >().

Referenced by prsqrt< Packet4f >().

Here is the call graph for this function:

Here is the caller graph for this function:

prsqrt< Packet2d >() [2/2]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d Eigen::internal::prsqrt< Packet2d >

(

const Packet2d &

x

)

                                             {
  // Unfortunately we can't use the much faster mm_rqsrt_pd since it only provides an approximation.
  return pset1<Packet2d>(1.0) / psqrt<Packet2d>(x);
}

References pset1< Packet2d >(), and psqrt< Packet2d >().

Here is the call graph for this function:

prsqrt< Packet4d >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d Eigen::internal::prsqrt< Packet4d >

(

const Packet4d &

x

)

                                             {
  _EIGEN_DECLARE_CONST_Packet4d(one, 1.0);
  return _mm256_div_pd(p4d_one, _mm256_sqrt_pd(x));
}

References _EIGEN_DECLARE_CONST_Packet4d.

prsqrt< Packet4f >() [1/3]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::prsqrt< Packet4f >

(

const Packet4f &

x

)

{
  return  vec_rsqrt(x);
}

prsqrt< Packet4f >() [2/3]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::prsqrt< Packet4f >

(

const Packet4f &

x

)

                                             {
  // Unfortunately we can't use the much faster mm_rqsrt_ps since it only provides an approximation.
  return _mm_div_ps(pset1<Packet4f>(1.0f), _mm_sqrt_ps(x));
}

References pset1< Packet4f >().

Here is the call graph for this function:

prsqrt< Packet4f >() [3/3]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::prsqrt< Packet4f >

(

const Packet4f &

x

)

                                             {
  Packet4f res;
  res.v4f[0] = prsqrt<Packet2d>(x.v4f[0]);
  res.v4f[1] = prsqrt<Packet2d>(x.v4f[1]);
  return res;
}

References prsqrt< Packet2d >(), and Eigen::internal::Packet4f::v4f.

Here is the call graph for this function:

prsqrt< Packet8f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f Eigen::internal::prsqrt< Packet8f >

(

const Packet8f &

x

)

                                             {
  _EIGEN_DECLARE_CONST_Packet8f(one, 1.0f);
  return _mm256_div_ps(p8f_one, _mm256_sqrt_ps(x));
}

References _EIGEN_DECLARE_CONST_Packet8f.

pscatter()

template<typename Scalar , typename Packet >

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter ( Scalar *  to, const Packet &  from, Index    )

inline

 { pstore(to, from); }

References pstore().

Here is the call graph for this function:

pscatter< double, Packet2d >() [1/2]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< double, Packet2d > ( double *  to, const Packet2d &  from, Index  stride  )

inline

{
  to[stride*0] = _mm_cvtsd_f64(from);
  to[stride*1] = _mm_cvtsd_f64(_mm_shuffle_pd(from, from, 1));
}

pscatter< double, Packet2d >() [2/2]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< double, Packet2d > ( double *  to, const Packet2d &  from, Index  stride  )

inline

{
  double EIGEN_ALIGN16 af[2];
  pstore<double>(af, from);
  to[0*stride] = af[0];
  to[1*stride] = af[1];
}

References EIGEN_ALIGN16, and pstore< double >().

Here is the call graph for this function:

pscatter< double, Packet4d >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< double, Packet4d > ( double *  to, const Packet4d &  from, Index  stride  )

inline

{
  __m128d low = _mm256_extractf128_pd(from, 0);
  to[stride*0] = _mm_cvtsd_f64(low);
  to[stride*1] = _mm_cvtsd_f64(_mm_shuffle_pd(low, low, 1));
  __m128d high = _mm256_extractf128_pd(from, 1);
  to[stride*2] = _mm_cvtsd_f64(high);
  to[stride*3] = _mm_cvtsd_f64(_mm_shuffle_pd(high, high, 1));
}

pscatter< double, Packet8d >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< double, Packet8d > ( double *  to, const Packet8d &  from, Index  stride  )

inline

                                                                       {
  Packet8i stride_vector = _mm256_set1_epi32(stride);
  Packet8i stride_multiplier = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
  Packet8i indices = _mm256_mullo_epi32(stride_vector, stride_multiplier);
  _mm512_i32scatter_pd(to, indices, from, 8);
}

pscatter< float, Packet16f >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, Packet16f > ( float *  to, const Packet16f &  from, Index  stride  )

inline

                                                                       {
  Packet16i stride_vector = _mm512_set1_epi32(stride);
  Packet16i stride_multiplier =
      _mm512_set_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
  Packet16i indices = _mm512_mullo_epi32(stride_vector, stride_multiplier);
  _mm512_i32scatter_ps(to, indices, from, 4);
}

pscatter< float, Packet4f >() [1/4]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, Packet4f > ( float *  to, const Packet4f &  from, Index  stride  )

inline

{
  float EIGEN_ALIGN16 af[4];
  pstore<float>(af, from);
  to[0*stride] = af[0];
  to[1*stride] = af[1];
  to[2*stride] = af[2];
  to[3*stride] = af[3];
}

References EIGEN_ALIGN16, and pstore< float >().

Here is the call graph for this function:

pscatter< float, Packet4f >() [2/4]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, Packet4f > ( float *  to, const Packet4f &  from, Index  stride  )

inline

{
  to[stride*0] = vgetq_lane_f32(from, 0);
  to[stride*1] = vgetq_lane_f32(from, 1);
  to[stride*2] = vgetq_lane_f32(from, 2);
  to[stride*3] = vgetq_lane_f32(from, 3);
}

pscatter< float, Packet4f >() [3/4]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, Packet4f > ( float *  to, const Packet4f &  from, Index  stride  )

inline

{
  to[stride*0] = _mm_cvtss_f32(from);
  to[stride*1] = _mm_cvtss_f32(_mm_shuffle_ps(from, from, 1));
  to[stride*2] = _mm_cvtss_f32(_mm_shuffle_ps(from, from, 2));
  to[stride*3] = _mm_cvtss_f32(_mm_shuffle_ps(from, from, 3));
}

pscatter< float, Packet4f >() [4/4]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, Packet4f > ( float *  to, const Packet4f &  from, Index  stride  )

inline

{
  float EIGEN_ALIGN16 ai[4];
  pstore<float>((float *)ai, from);
  to[0*stride] = ai[0];
  to[1*stride] = ai[1];
  to[2*stride] = ai[2];
  to[3*stride] = ai[3];
}

References EIGEN_ALIGN16, and pstore< float >().

Here is the call graph for this function:

pscatter< float, Packet8f >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, Packet8f > ( float *  to, const Packet8f &  from, Index  stride  )

inline

{
  __m128 low = _mm256_extractf128_ps(from, 0);
  to[stride*0] = _mm_cvtss_f32(low);
  to[stride*1] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 1));
  to[stride*2] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 2));
  to[stride*3] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 3));
 
  __m128 high = _mm256_extractf128_ps(from, 1);
  to[stride*4] = _mm_cvtss_f32(high);
  to[stride*5] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 1));
  to[stride*6] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 2));
  to[stride*7] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 3));
}

pscatter< int, Packet4i >() [1/3]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< int, Packet4i > ( int *  to, const Packet4i &  from, Index  stride  )

inline

{
  int EIGEN_ALIGN16 ai[4];
  pstore<int>((int *)ai, from);
  to[0*stride] = ai[0];
  to[1*stride] = ai[1];
  to[2*stride] = ai[2];
  to[3*stride] = ai[3];
}

References EIGEN_ALIGN16, and pstore< int >().

Here is the call graph for this function:

pscatter< int, Packet4i >() [2/3]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< int, Packet4i > ( int *  to, const Packet4i &  from, Index  stride  )

inline

{
  to[stride*0] = _mm_cvtsi128_si32(from);
  to[stride*1] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 1));
  to[stride*2] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 2));
  to[stride*3] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 3));
}

pscatter< int, Packet4i >() [3/3]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< int, Packet4i > ( int *  to, const Packet4i &  from, Index  stride  )

inline

{
  int EIGEN_ALIGN16 ai[4];
  pstore<int>((int *)ai, from);
  to[0*stride] = ai[0];
  to[1*stride] = ai[1];
  to[2*stride] = ai[2];
  to[3*stride] = ai[3];
}

References EIGEN_ALIGN16, and pstore< int >().

Here is the call graph for this function:

pscatter< int32_t, Packet4i >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< int32_t, Packet4i > ( int32_t *  to, const Packet4i &  from, Index  stride  )

inline

{
  to[stride*0] = vgetq_lane_s32(from, 0);
  to[stride*1] = vgetq_lane_s32(from, 1);
  to[stride*2] = vgetq_lane_s32(from, 2);
  to[stride*3] = vgetq_lane_s32(from, 3);
}

pscatter< std::complex< double >, Packet1cd >()

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< double >, Packet1cd > ( std::complex< double > *  to, const Packet1cd &  from, Index stride  EIGEN_UNUSED  )

inline

{
  pstore<std::complex<double> >(to, from);
}

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

{
  __m128d low = _mm256_extractf128_pd(from.v, 0);
  to[stride*0] = std::complex<double>(_mm_cvtsd_f64(low), _mm_cvtsd_f64(_mm_shuffle_pd(low, low, 1)));
  __m128d high = _mm256_extractf128_pd(from.v, 1);
  to[stride*1] = std::complex<double>(_mm_cvtsd_f64(high), _mm_cvtsd_f64(_mm_shuffle_pd(high, high, 1)));
}

pscatter< std::complex< float >, Packet2cf >() [1/4]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< float >, Packet2cf > ( std::complex< float > *  to, const Packet2cf &  from, Index  stride  )

inline

{
  std::complex<float> EIGEN_ALIGN16 af[2];
  pstore<std::complex<float> >((std::complex<float> *) af, from);
  to[0*stride] = af[0];
  to[1*stride] = af[1];
}

References EIGEN_ALIGN16.

pscatter< std::complex< float >, Packet2cf >() [2/4]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< float >, Packet2cf > ( std::complex< float > *  to, const Packet2cf &  from, Index  stride  )

inline

{
  to[stride*0] = std::complex<float>(vgetq_lane_f32(from.v, 0), vgetq_lane_f32(from.v, 1));
  to[stride*1] = std::complex<float>(vgetq_lane_f32(from.v, 2), vgetq_lane_f32(from.v, 3));
}

pscatter< std::complex< float >, Packet2cf >() [3/4]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< float >, Packet2cf > ( std::complex< float > *  to, const Packet2cf &  from, Index  stride  )

inline

{
  to[stride*0] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(from.v, from.v, 0)),
                                     _mm_cvtss_f32(_mm_shuffle_ps(from.v, from.v, 1)));
  to[stride*1] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(from.v, from.v, 2)),
                                     _mm_cvtss_f32(_mm_shuffle_ps(from.v, from.v, 3)));
}

pscatter< std::complex< float >, Packet2cf >() [4/4]

template<>

EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< float >, Packet2cf > ( std::complex< float > *  to, const Packet2cf &  from, Index  stride  )

inline

{
  std::complex<float> EIGEN_ALIGN16 af[2];
  pstore<std::complex<float> >((std::complex<float> *) af, from);
  to[0*stride] = af[0];
  to[1*stride] = af[1];
}

References EIGEN_ALIGN16.

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

{
  __m128 low = _mm256_extractf128_ps(from.v, 0);
  to[stride*0] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(low, low, 0)),
                                     _mm_cvtss_f32(_mm_shuffle_ps(low, low, 1)));
  to[stride*1] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(low, low, 2)),
                                     _mm_cvtss_f32(_mm_shuffle_ps(low, low, 3)));
 
  __m128 high = _mm256_extractf128_ps(from.v, 1);
  to[stride*2] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(high, high, 0)),
                                     _mm_cvtss_f32(_mm_shuffle_ps(high, high, 1)));
  to[stride*3] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(high, high, 2)),
                                     _mm_cvtss_f32(_mm_shuffle_ps(high, high, 3)));
 
}

pset1()

template<typename Packet >

EIGEN_DEVICE_FUNC Packet Eigen::internal::pset1 ( const typename unpacket_traits< Packet >::type &  a )

inline

{ return a; }

pset1< Packet16f >()

template<>

EIGEN_STRONG_INLINE Packet16f Eigen::internal::pset1< Packet16f >

(

const float &

from

)

                                                                  {
  return _mm512_set1_ps(from);
}

Referenced by pstore1< Packet16f >().

Here is the caller graph for this function:

pset1< Packet16i >()

template<>

EIGEN_STRONG_INLINE Packet16i Eigen::internal::pset1< Packet16i >

(

const int &

from

)

                                                                {
  return _mm512_set1_epi32(from);
}

Referenced by pstore1< Packet16i >().

Here is the caller graph for this function:

pset1< Packet1cd >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pset1< Packet1cd >

(

const std::complex< double > &

from

)

{ /* here we really have to use unaligned loads :( */ return ploadu<Packet1cd>(&from); }

References ploadu< Packet1cd >().

Referenced by pinsertfirst(), pinsertlast(), and ploaddup< Packet1cd >().

Here is the call graph for this function:

Here is the caller graph for this function:

pset1< Packet1cd >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pset1< Packet1cd >

(

const std::complex< double > &

from

)

{ /* here we really have to use unaligned loads :( */ return ploadu<Packet1cd>(&from); }

References ploadu< Packet1cd >().

Here is the call graph for this function:

pset1< Packet2cd >()

template<>

EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pset1< Packet2cd >

(

const std::complex< double > &

from

)

{
  // in case casting to a __m128d* is really not safe, then we can still fallback to this version: (much slower though)
//   return Packet2cd(_mm256_loadu2_m128d((const double*)&from,(const double*)&from));
    return Packet2cd(_mm256_broadcast_pd((const __m128d*)(const void*)&from));
}

Referenced by pinsertfirst(), pinsertlast(), and ploaddup< Packet2cd >().

Here is the caller graph for this function:

pset1< Packet2cf >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pset1< Packet2cf >

(

const std::complex< float > &

from

)

{
  Packet2cf res;
  if((std::ptrdiff_t(&from) % 16) == 0)
    res.v = pload<Packet4f>((const float *)&from);
  else
    res.v = ploadu<Packet4f>((const float *)&from);
  res.v = vec_perm(res.v, res.v, p16uc_PSET64_HI);
  return res;
}

References p16uc_PSET64_HI, pload< Packet4f >(), ploadu< Packet4f >(), and Eigen::internal::Packet2cf::v.

Referenced by ploaddup< Packet2cf >().

Here is the call graph for this function:

Here is the caller graph for this function:

pset1< Packet2cf >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pset1< Packet2cf >

(

const std::complex< float > &

from

)

{
  float32x2_t r64;
  r64 = vld1_f32((const float *)&from);
 
  return Packet2cf(vcombine_f32(r64, r64));
}

pset1< Packet2cf >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pset1< Packet2cf >

(

const std::complex< float > &

from

)

{
  Packet2cf res;
#if EIGEN_GNUC_AT_MOST(4,2)
  // Workaround annoying "may be used uninitialized in this function" warning with gcc 4.2
  res.v = _mm_loadl_pi(_mm_set1_ps(0.0f), reinterpret_cast<const __m64*>(&from));
#elif EIGEN_GNUC_AT_LEAST(4,6)
  // Suppress annoying "may be used uninitialized in this function" warning with gcc >= 4.6
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wuninitialized"
  res.v = _mm_loadl_pi(res.v, (const __m64*)&from);
  #pragma GCC diagnostic pop
#else
  res.v = _mm_loadl_pi(res.v, (const __m64*)&from);
#endif
  return Packet2cf(_mm_movelh_ps(res.v,res.v));
}

pset1< Packet2cf >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pset1< Packet2cf >

(

const std::complex< float > &

from

)

{
  Packet2cf res;
  res.cd[0] = Packet1cd(vec_ld2f((const float *)&from));
  res.cd[1] = res.cd[0];
  return res;
}

pset1< Packet2d >() [1/2]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pset1< Packet2d >

(

const double &

from

)

{ return _mm_set1_pd(from); }

Referenced by pinsertfirst(), pinsertlast(), ploaddup< Packet2d >(), plset< Packet2d >(), prsqrt< Packet2d >(), pset1< Packet4f >(), and Eigen::internal::quat_product< Architecture::SSE, Derived, OtherDerived, double >::run().

Here is the caller graph for this function:

pset1< Packet2d >() [2/2]

template<>

EIGEN_STRONG_INLINE Packet2d Eigen::internal::pset1< Packet2d >

(

const double &

from

)

                                                                            {
  return vec_splats(from);
}

pset1< Packet4cf >()

template<>

EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pset1< Packet4cf >

(

const std::complex< float > &

from

)

{
  return Packet4cf(_mm256_castpd_ps(_mm256_broadcast_sd((const double*)(const void*)&from)));
}

Referenced by pinsertfirst(), and pinsertlast().

Here is the caller graph for this function:

pset1< Packet4d >()

template<>

EIGEN_STRONG_INLINE Packet4d Eigen::internal::pset1< Packet4d >

(

const double &

from

)

{ return _mm256_set1_pd(from); }

Referenced by pinsertfirst(), pinsertlast(), and pstore1< Packet4d >().

Here is the caller graph for this function:

pset1< Packet4f >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pset1< Packet4f >

(

const float &

from

)

                                                                            {
  Packet4f v = {from, from, from, from};
  return v;
}

Referenced by pgather< float, Packet4f >(), pgather< std::complex< float >, Packet2cf >(), pinsertfirst(), pinsertlast(), plset< Packet4f >(), and prsqrt< Packet4f >().

Here is the caller graph for this function:

pset1< Packet4f >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pset1< Packet4f >

(

const float &

from

)

{ return vdupq_n_f32(from); }

pset1< Packet4f >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pset1< Packet4f >

(

const float &

from

)

{ return _mm_set_ps1(from); }

pset1< Packet4f >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::pset1< Packet4f >

(

const float &

from

)

{
  Packet4f to;
  to.v4f[0] = pset1<Packet2d>(static_cast<const double&>(from));
  to.v4f[1] = to.v4f[0];
  return to;
}

References pset1< Packet2d >(), and Eigen::internal::Packet4f::v4f.

Here is the call graph for this function:

pset1< Packet4i >() [1/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pset1< Packet4i >

(

const int &

from

)

                                                                              {
  Packet4i v = {from, from, from, from};
  return v;
}

Referenced by pdiv< Packet4i >(), pgather< int32_t, Packet4i >(), plset< Packet4i >(), and plset< Packet4i >().

Here is the caller graph for this function:

pset1< Packet4i >() [2/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pset1< Packet4i >

(

const int &

from

)

{ return _mm_set1_epi32(from); }

pset1< Packet4i >() [3/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pset1< Packet4i >

(

const int &

from

)

{
  return vec_splats(from);
}

pset1< Packet4i >() [4/4]

template<>

EIGEN_STRONG_INLINE Packet4i Eigen::internal::pset1< Packet4i >

(

const int32_t &

from

)

{ return vdupq_n_s32(from); }

pset1< Packet8d >()

template<>

EIGEN_STRONG_INLINE Packet8d Eigen::internal::pset1< Packet8d >

(

const double &

from

)

                                                                 {
  return _mm512_set1_pd(from);
}

Referenced by pstore1< Packet8d >().

Here is the caller graph for this function:

pset1< Packet8f >()

template<>

EIGEN_STRONG_INLINE Packet8f Eigen::internal::pset1< Packet8f >

(

const float &

from

)

{ return _mm256_set1_ps(from); }

Referenced by pinsertfirst(), pinsertlast(), and pstore1< Packet8f >().

Here is the caller graph for this function:

pset1< Packet8i >()

template<>

EIGEN_STRONG_INLINE Packet8i Eigen::internal::pset1< Packet8i >

(

const int &

from

)

{ return _mm256_set1_epi32(from); }

Referenced by pdiv< Packet8i >(), and pstore1< Packet8i >().

Here is the caller graph for this function:

pshiftleft()

Packet8i Eigen::internal::pshiftleft ( Packet8i  v, int  n  )

inline

{
#ifdef EIGEN_VECTORIZE_AVX2
  return _mm256_slli_epi32(v, n);
#else
  __m128i lo = _mm_slli_epi32(_mm256_extractf128_si256(v, 0), n);
  __m128i hi = _mm_slli_epi32(_mm256_extractf128_si256(v, 1), n);
  return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
#endif
}

Referenced by pexp< Packet8f >(), and psin< Packet8f >().

Here is the caller graph for this function:

pshiftright()

Packet8f Eigen::internal::pshiftright ( Packet8f  v, int  n  )

inline

{
#ifdef EIGEN_VECTORIZE_AVX2
  return _mm256_cvtepi32_ps(_mm256_srli_epi32(_mm256_castps_si256(v), n));
#else
  __m128i lo = _mm_srli_epi32(_mm256_extractf128_si256(_mm256_castps_si256(v), 0), n);
  __m128i hi = _mm_srli_epi32(_mm256_extractf128_si256(_mm256_castps_si256(v), 1), n);
  return _mm256_cvtepi32_ps(_mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1));
#endif
}

Referenced by plog< Packet8f >().

Here is the caller graph for this function:

psin()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::psin

(

const Packet &

a

)

{ using std::sin; return sin(a); }

References sin().

Here is the call graph for this function:

psin< Packet4f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::psin< Packet4f >

(

const Packet4f &

_x

)

{
  Packet4f x = _x;
  _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f);
  _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
 
  _EIGEN_DECLARE_CONST_Packet4i(1, 1);
  _EIGEN_DECLARE_CONST_Packet4i(not1, ~1);
  _EIGEN_DECLARE_CONST_Packet4i(2, 2);
  _EIGEN_DECLARE_CONST_Packet4i(4, 4);
 
  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(sign_mask, 0x80000000);
 
  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP1,-0.78515625f);
  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP2, -2.4187564849853515625e-4f);
  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP3, -3.77489497744594108e-8f);
  _EIGEN_DECLARE_CONST_Packet4f(sincof_p0, -1.9515295891E-4f);
  _EIGEN_DECLARE_CONST_Packet4f(sincof_p1,  8.3321608736E-3f);
  _EIGEN_DECLARE_CONST_Packet4f(sincof_p2, -1.6666654611E-1f);
  _EIGEN_DECLARE_CONST_Packet4f(coscof_p0,  2.443315711809948E-005f);
  _EIGEN_DECLARE_CONST_Packet4f(coscof_p1, -1.388731625493765E-003f);
  _EIGEN_DECLARE_CONST_Packet4f(coscof_p2,  4.166664568298827E-002f);
  _EIGEN_DECLARE_CONST_Packet4f(cephes_FOPI, 1.27323954473516f); // 4 / M_PI
 
  Packet4f xmm1, xmm2, xmm3, sign_bit, y;
 
  Packet4i emm0, emm2;
  sign_bit = x;
  /* take the absolute value */
  x = pabs(x);
 
  /* take the modulo */
 
  /* extract the sign bit (upper one) */
  sign_bit = _mm_and_ps(sign_bit, p4f_sign_mask);
 
  /* scale by 4/Pi */
  y = pmul(x, p4f_cephes_FOPI);
 
  /* store the integer part of y in mm0 */
  emm2 = _mm_cvttps_epi32(y);
  /* j=(j+1) & (~1) (see the cephes sources) */
  emm2 = _mm_add_epi32(emm2, p4i_1);
  emm2 = _mm_and_si128(emm2, p4i_not1);
  y = _mm_cvtepi32_ps(emm2);
  /* get the swap sign flag */
  emm0 = _mm_and_si128(emm2, p4i_4);
  emm0 = _mm_slli_epi32(emm0, 29);
  /* get the polynom selection mask
     there is one polynom for 0 <= x <= Pi/4
     and another one for Pi/4<x<=Pi/2
 
     Both branches will be computed.
  */
  emm2 = _mm_and_si128(emm2, p4i_2);
  emm2 = _mm_cmpeq_epi32(emm2, _mm_setzero_si128());
 
  Packet4f swap_sign_bit = _mm_castsi128_ps(emm0);
  Packet4f poly_mask = _mm_castsi128_ps(emm2);
  sign_bit = _mm_xor_ps(sign_bit, swap_sign_bit);
 
  /* The magic pass: "Extended precision modular arithmetic"
     x = ((x - y * DP1) - y * DP2) - y * DP3; */
  xmm1 = pmul(y, p4f_minus_cephes_DP1);
  xmm2 = pmul(y, p4f_minus_cephes_DP2);
  xmm3 = pmul(y, p4f_minus_cephes_DP3);
  x = padd(x, xmm1);
  x = padd(x, xmm2);
  x = padd(x, xmm3);
 
  /* Evaluate the first polynom  (0 <= x <= Pi/4) */
  y = p4f_coscof_p0;
  Packet4f z = _mm_mul_ps(x,x);
 
  y = pmadd(y, z, p4f_coscof_p1);
  y = pmadd(y, z, p4f_coscof_p2);
  y = pmul(y, z);
  y = pmul(y, z);
  Packet4f tmp = pmul(z, p4f_half);
  y = psub(y, tmp);
  y = padd(y, p4f_1);
 
  /* Evaluate the second polynom  (Pi/4 <= x <= 0) */
 
  Packet4f y2 = p4f_sincof_p0;
  y2 = pmadd(y2, z, p4f_sincof_p1);
  y2 = pmadd(y2, z, p4f_sincof_p2);
  y2 = pmul(y2, z);
  y2 = pmul(y2, x);
  y2 = padd(y2, x);
 
  /* select the correct result from the two polynoms */
  y2 = _mm_and_ps(poly_mask, y2);
  y = _mm_andnot_ps(poly_mask, y);
  y = _mm_or_ps(y,y2);
  /* update the sign */
  return _mm_xor_ps(y, sign_bit);
}

References _EIGEN_DECLARE_CONST_Packet4f, _EIGEN_DECLARE_CONST_Packet4f_FROM_INT, _EIGEN_DECLARE_CONST_Packet4i, pabs(), padd(), pmadd(), pmul(), psub(), and y.

Here is the call graph for this function:

psin< Packet8f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f Eigen::internal::psin< Packet8f >

(

const Packet8f &

_x

)

                                   {
  Packet8f x = _x;
 
  // Some useful values.
  _EIGEN_DECLARE_CONST_Packet8i(one, 1);
  _EIGEN_DECLARE_CONST_Packet8f(one, 1.0f);
  _EIGEN_DECLARE_CONST_Packet8f(two, 2.0f);
  _EIGEN_DECLARE_CONST_Packet8f(one_over_four, 0.25f);
  _EIGEN_DECLARE_CONST_Packet8f(one_over_pi, 3.183098861837907e-01f);
  _EIGEN_DECLARE_CONST_Packet8f(neg_pi_first, -3.140625000000000e+00f);
  _EIGEN_DECLARE_CONST_Packet8f(neg_pi_second, -9.670257568359375e-04f);
  _EIGEN_DECLARE_CONST_Packet8f(neg_pi_third, -6.278329571784980e-07f);
  _EIGEN_DECLARE_CONST_Packet8f(four_over_pi, 1.273239544735163e+00f);
 
  // Map x from [-Pi/4,3*Pi/4] to z in [-1,3] and subtract the shifted period.
  Packet8f z = pmul(x, p8f_one_over_pi);
  Packet8f shift = _mm256_floor_ps(padd(z, p8f_one_over_four));
  x = pmadd(shift, p8f_neg_pi_first, x);
  x = pmadd(shift, p8f_neg_pi_second, x);
  x = pmadd(shift, p8f_neg_pi_third, x);
  z = pmul(x, p8f_four_over_pi);
 
  // Make a mask for the entries that need flipping, i.e. wherever the shift
  // is odd.
  Packet8i shift_ints = _mm256_cvtps_epi32(shift);
  Packet8i shift_isodd = _mm256_castps_si256(_mm256_and_ps(_mm256_castsi256_ps(shift_ints), _mm256_castsi256_ps(p8i_one)));
  Packet8i sign_flip_mask = pshiftleft(shift_isodd, 31);
 
  // Create a mask for which interpolant to use, i.e. if z > 1, then the mask
  // is set to ones for that entry.
  Packet8f ival_mask = _mm256_cmp_ps(z, p8f_one, _CMP_GT_OQ);
 
  // Evaluate the polynomial for the interval [1,3] in z.
  _EIGEN_DECLARE_CONST_Packet8f(coeff_right_0, 9.999999724233232e-01f);
  _EIGEN_DECLARE_CONST_Packet8f(coeff_right_2, -3.084242535619928e-01f);
  _EIGEN_DECLARE_CONST_Packet8f(coeff_right_4, 1.584991525700324e-02f);
  _EIGEN_DECLARE_CONST_Packet8f(coeff_right_6, -3.188805084631342e-04f);
  Packet8f z_minus_two = psub(z, p8f_two);
  Packet8f z_minus_two2 = pmul(z_minus_two, z_minus_two);
  Packet8f right = pmadd(p8f_coeff_right_6, z_minus_two2, p8f_coeff_right_4);
  right = pmadd(right, z_minus_two2, p8f_coeff_right_2);
  right = pmadd(right, z_minus_two2, p8f_coeff_right_0);
 
  // Evaluate the polynomial for the interval [-1,1] in z.
  _EIGEN_DECLARE_CONST_Packet8f(coeff_left_1, 7.853981525427295e-01f);
  _EIGEN_DECLARE_CONST_Packet8f(coeff_left_3, -8.074536727092352e-02f);
  _EIGEN_DECLARE_CONST_Packet8f(coeff_left_5, 2.489871967827018e-03f);
  _EIGEN_DECLARE_CONST_Packet8f(coeff_left_7, -3.587725841214251e-05f);
  Packet8f z2 = pmul(z, z);
  Packet8f left = pmadd(p8f_coeff_left_7, z2, p8f_coeff_left_5);
  left = pmadd(left, z2, p8f_coeff_left_3);
  left = pmadd(left, z2, p8f_coeff_left_1);
  left = pmul(left, z);
 
  // Assemble the results, i.e. select the left and right polynomials.
  left = _mm256_andnot_ps(ival_mask, left);
  right = _mm256_and_ps(ival_mask, right);
  Packet8f res = _mm256_or_ps(left, right);
 
  // Flip the sign on the odd intervals and return the result.
  res = _mm256_xor_ps(res, _mm256_castsi256_ps(sign_flip_mask));
  return res;
}

References _EIGEN_DECLARE_CONST_Packet8f, _EIGEN_DECLARE_CONST_Packet8i, padd(), pmadd(), pmul(), pshiftleft(), and psub().

Here is the call graph for this function:

psinh()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::psinh

(

const Packet &

a

)

{ using std::sinh; return sinh(a); }

References sinh().

Here is the call graph for this function:

psqrt()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::psqrt

(

const Packet &

a

)

{ using std::sqrt; return sqrt(a); }

References sqrt().

Referenced by prsqrt().

Here is the call graph for this function:

Here is the caller graph for this function:

psqrt< Packet2d >() [1/2]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d Eigen::internal::psqrt< Packet2d >

(

const Packet2d &

x

)

{ return _mm_sqrt_pd(x); }

Referenced by prsqrt< Packet2d >(), and psqrt< Packet4f >().

Here is the caller graph for this function:

psqrt< Packet2d >() [2/2]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d Eigen::internal::psqrt< Packet2d >

(

const Packet2d &

x

)

{
  return  __builtin_s390_vfsqdb(x);
}

psqrt< Packet4d >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d Eigen::internal::psqrt< Packet4d >

(

const Packet4d &

x

)

                                            {
  return _mm256_sqrt_pd(x);
}

psqrt< Packet4f >() [1/2]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::psqrt< Packet4f >

(

const Packet4f &

x

)

{ return _mm_sqrt_ps(x); }

psqrt< Packet4f >() [2/2]

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::psqrt< Packet4f >

(

const Packet4f &

x

)

{
  Packet4f res;
  res.v4f[0] = psqrt<Packet2d>(x.v4f[0]);
  res.v4f[1] = psqrt<Packet2d>(x.v4f[1]);
  return res;
}

References psqrt< Packet2d >(), and Eigen::internal::Packet4f::v4f.

Here is the call graph for this function:

psqrt< Packet8f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f Eigen::internal::psqrt< Packet8f >

(

const Packet8f &

x

)

                                            {
  return _mm256_sqrt_ps(x);
}

pstore()

template<typename Scalar , typename Packet >

EIGEN_DEVICE_FUNC void Eigen::internal::pstore ( Scalar *  to, const Packet &  from  )

inline

{ (*to) = from; }

Referenced by Eigen::internal::gemm_pack_lhs< Scalar, Index, DataMapper, Pack1, Pack2, ColMajor, Conjugate, PanelMode >::operator()(), Eigen::internal::gemm_pack_lhs< Scalar, Index, DataMapper, Pack1, Pack2, RowMajor, Conjugate, PanelMode >::operator()(), pfirst< Packet2cf >(), pfirst< Packet2d >(), pfirst< Packet4i >(), predux_max< Packet4i >(), predux_min< Packet4i >(), predux_mul< Packet4i >(), pscatter(), pstore1(), pstore1< Packet16f >(), pstore1< Packet16i >(), pstore1< Packet2d >(), pstore1< Packet4d >(), pstore1< Packet4f >(), pstore1< Packet8d >(), pstore1< Packet8f >(), pstore1< Packet8i >(), pstore< std::complex< double > >(), pstore< std::complex< double > >(), pstore< std::complex< float > >(), pstore< std::complex< float > >(), pstoret(), Eigen::internal::general_matrix_vector_product< Index, LhsScalar, LhsMapper, ColMajor, ConjugateLhs, RhsScalar, RhsMapper, ConjugateRhs, Version >::run(), Eigen::internal::selfadjoint_matrix_vector_product< Scalar, Index, StorageOrder, UpLo, ConjugateLhs, ConjugateRhs, Version >::run(), and Eigen::internal::apply_rotation_in_the_plane_selector< Scalar, OtherScalar, SizeAtCompileTime, MinAlignment, true >::run().

Here is the caller graph for this function:

pstore1()

template<typename Packet >

void Eigen::internal::pstore1 ( typename unpacket_traits< Packet >::type *  to, const typename unpacket_traits< Packet >::type &  a  )

inline

{
  pstore(to, pset1<Packet>(a));
}

References pstore().

Here is the call graph for this function:

pstore1< Packet16f >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet16f >	(	float *	to,
		const float &	a
	)

                                                                       {
  Packet16f pa = pset1<Packet16f>(a);
  pstore(to, pa);
}

References pset1< Packet16f >(), and pstore().

Here is the call graph for this function:

pstore1< Packet16i >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet16i >	(	int *	to,
		const int &	a
	)

                                                                   {
  Packet16i pa = pset1<Packet16i>(a);
  pstore(to, pa);
}

References pset1< Packet16i >(), and pstore().

Here is the call graph for this function:

pstore1< Packet2d >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet2d >	(	double *	to,
		const double &	a
	)

{
  Packet2d pa = _mm_set_sd(a);
  pstore(to, Packet2d(vec2d_swizzle1(pa,0,0)));
}

References pstore(), and vec2d_swizzle1.

Here is the call graph for this function:

pstore1< Packet4d >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet4d >	(	double *	to,
		const double &	a
	)

{
  Packet4d pa = pset1<Packet4d>(a);
  pstore(to, pa);
}

References pset1< Packet4d >(), and pstore().

Here is the call graph for this function:

pstore1< Packet4f >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet4f >	(	float *	to,
		const float &	a
	)

{
  Packet4f pa = _mm_set_ss(a);
  pstore(to, Packet4f(vec4f_swizzle1(pa,0,0,0,0)));
}

References pstore(), and vec4f_swizzle1.

Here is the call graph for this function:

pstore1< Packet8d >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet8d >	(	double *	to,
		const double &	a
	)

                                                                        {
  Packet8d pa = pset1<Packet8d>(a);
  pstore(to, pa);
}

References pset1< Packet8d >(), and pstore().

Here is the call graph for this function:

pstore1< Packet8f >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet8f >	(	float *	to,
		const float &	a
	)

{
  Packet8f pa = pset1<Packet8f>(a);
  pstore(to, pa);
}

References pset1< Packet8f >(), and pstore().

Here is the call graph for this function:

pstore1< Packet8i >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet8i >	(	int *	to,
		const int &	a
	)

{
  Packet8i pa = pset1<Packet8i>(a);
  pstore(to, pa);
}

References pset1< Packet8i >(), and pstore().

Here is the call graph for this function:

pstore< double >() [1/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< double >	(	double *	to,
		const Packet2d &	from
	)

{ EIGEN_DEBUG_ALIGNED_STORE _mm_store_pd(to, from); }

References EIGEN_DEBUG_ALIGNED_STORE.

pstore< double >() [2/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< double >	(	double *	to,
		const Packet2d &	from
	)

{
  // FIXME: No intrinsic yet
  EIGEN_DEBUG_ALIGNED_STORE
  Packet *vto;
  vto = (Packet *) to;
  vto->v2d = from;
}

References EIGEN_DEBUG_ALIGNED_STORE, and Eigen::internal::Packet::v2d.

pstore< double >() [3/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< double >	(	double *	to,
		const Packet4d &	from
	)

{ EIGEN_DEBUG_ALIGNED_STORE _mm256_store_pd(to, from); }

References EIGEN_DEBUG_ALIGNED_STORE.

Referenced by pscatter< double, Packet2d >(), and pstoreu< double >().

Here is the caller graph for this function:

pstore< double >() [4/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< double >	(	double *	to,
		const Packet8d &	from
	)

                                                                          {
  EIGEN_DEBUG_ALIGNED_STORE _mm512_store_pd(to, from);
}

References EIGEN_DEBUG_ALIGNED_STORE.

pstore< float >() [1/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< float >	(	float *	to,
		const Packet16f &	from
	)

                                                                         {
  EIGEN_DEBUG_ALIGNED_STORE _mm512_store_ps(to, from);
}

References EIGEN_DEBUG_ALIGNED_STORE.

pstore< float >() [2/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< float >	(	float *	to,
		const Packet4f &	from
	)

{
  EIGEN_DEBUG_ALIGNED_STORE
#ifdef __VSX__
  vec_vsx_st(from, 0, to);
#else
  vec_st(from, 0, to);
#endif
}

References EIGEN_DEBUG_ALIGNED_STORE.

Referenced by pscatter< float, Packet4f >(), and pstoreu< float >().

Here is the caller graph for this function:

pstore< float >() [3/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< float >	(	float *	to,
		const Packet4f &	from
	)

{ EIGEN_DEBUG_ALIGNED_STORE vst1q_f32(to, from); }

References EIGEN_DEBUG_ALIGNED_STORE.

pstore< float >() [4/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< float >	(	float *	to,
		const Packet4f &	from
	)

{ EIGEN_DEBUG_ALIGNED_STORE _mm_store_ps(to, from); }

References EIGEN_DEBUG_ALIGNED_STORE.

pstore< float >() [5/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< float >	(	float *	to,
		const Packet4f &	from
	)

{
  // FIXME: No intrinsic yet
  EIGEN_DEBUG_ALIGNED_STORE
  vec_st2f(from.v4f[0], &to[0]);
  vec_st2f(from.v4f[1], &to[2]);
}

References EIGEN_DEBUG_ALIGNED_STORE, and Eigen::internal::Packet4f::v4f.

pstore< float >() [6/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< float >	(	float *	to,
		const Packet8f &	from
	)

{ EIGEN_DEBUG_ALIGNED_STORE _mm256_store_ps(to, from); }

References EIGEN_DEBUG_ALIGNED_STORE.

pstore< int >() [1/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int >	(	int *	to,
		const Packet16i &	from
	)

                                                                     {
  EIGEN_DEBUG_ALIGNED_STORE _mm512_storeu_si512(reinterpret_cast<__m512i*>(to),
                                                from);
}

References EIGEN_DEBUG_ALIGNED_STORE.

pstore< int >() [2/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int >	(	int *	to,
		const Packet4i &	from
	)

{
  EIGEN_DEBUG_ALIGNED_STORE
#ifdef __VSX__
  vec_vsx_st(from, 0, to);
#else
  vec_st(from, 0, to);
#endif
}

References EIGEN_DEBUG_ALIGNED_STORE.

Referenced by pscatter< int, Packet4i >(), and pstoreu< int >().

Here is the caller graph for this function:

pstore< int >() [3/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int >	(	int *	to,
		const Packet4i &	from
	)

{ EIGEN_DEBUG_ALIGNED_STORE _mm_store_si128(reinterpret_cast<__m128i*>(to), from); }

References EIGEN_DEBUG_ALIGNED_STORE.

pstore< int >() [4/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int >	(	int *	to,
		const Packet4i &	from
	)

{
  // FIXME: No intrinsic yet
  EIGEN_DEBUG_ALIGNED_STORE
  Packet *vto;
  vto = (Packet *) to;
  vto->v4i = from;
}

References EIGEN_DEBUG_ALIGNED_STORE, and Eigen::internal::Packet::v4i.

pstore< int >() [5/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int >	(	int *	to,
		const Packet8i &	from
	)

{ EIGEN_DEBUG_ALIGNED_STORE _mm256_storeu_si256(reinterpret_cast<__m256i*>(to), from); }

References EIGEN_DEBUG_ALIGNED_STORE.

pstore< int32_t >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< int32_t >	(	int32_t *	to,
		const Packet4i &	from
	)

{ EIGEN_DEBUG_ALIGNED_STORE vst1q_s32(to, from); }

References EIGEN_DEBUG_ALIGNED_STORE.

pstore< std::complex< double > >() [1/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< double > >	(	std::complex< double > *	to,
		const Packet1cd &	from
	)

{ EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, Packet2d(from.v)); }

References EIGEN_DEBUG_ALIGNED_STORE, and pstore().

Here is the call graph for this function:

pstore< std::complex< double > >() [2/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< double > >	(	std::complex< double > *	to,
		const Packet1cd &	from
	)

{ EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, from.v); }

References EIGEN_DEBUG_ALIGNED_STORE, and pstore().

Here is the call graph for this function:

pstore< std::complex< double > >() [3/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< double > >	(	std::complex< double > *	to,
		const Packet2cd &	from
	)

{ EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, from.v); }

References EIGEN_DEBUG_ALIGNED_STORE, and pstore().

Here is the call graph for this function:

pstore< std::complex< float > >() [1/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

{ pstore((float*)to, from.v); }

References pstore().

Here is the call graph for this function:

pstore< std::complex< float > >() [2/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

{ EIGEN_DEBUG_ALIGNED_STORE pstore((float*)to, from.v); }

References EIGEN_DEBUG_ALIGNED_STORE, and pstore().

Here is the call graph for this function:

pstore< std::complex< float > >() [3/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

{ EIGEN_DEBUG_ALIGNED_STORE pstore(&numext::real_ref(*to), Packet4f(from.v)); }

References EIGEN_DEBUG_ALIGNED_STORE, pstore(), and Eigen::numext::real_ref().

Here is the call graph for this function:

pstore< std::complex< float > >() [4/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

{ EIGEN_DEBUG_ALIGNED_STORE pstore((float*)to, from.v); }

References EIGEN_DEBUG_ALIGNED_STORE, and pstore().

Here is the call graph for this function:

pstore< std::complex< float > >() [5/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< float > >	(	std::complex< float > *	to,
		const Packet4cf &	from
	)

{ EIGEN_DEBUG_ALIGNED_STORE pstore(&numext::real_ref(*to), from.v); }

References EIGEN_DEBUG_ALIGNED_STORE, pstore(), and Eigen::numext::real_ref().

Here is the call graph for this function:

pstoret()

template<typename Scalar , typename Packet , int Alignment>

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void Eigen::internal::pstoret	(	Scalar *	to,
		const Packet &	from
	)

{
  if(Alignment >= unpacket_traits<Packet>::alignment)
    pstore(to, from);
  else
    pstoreu(to, from);
}

References pstore(), and pstoreu().

Here is the call graph for this function:

pstoreu()

template<typename Scalar , typename Packet >

EIGEN_DEVICE_FUNC void Eigen::internal::pstoreu ( Scalar *  to, const Packet &  from  )

inline

{  (*to) = from; }

Referenced by Eigen::internal::gemm_pack_rhs< Scalar, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode >::operator()(), Eigen::internal::gemm_pack_rhs< Scalar, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode >::operator()(), pstoret(), pstoreu< std::complex< double > >(), pstoreu< std::complex< double > >(), pstoreu< std::complex< float > >(), pstoreu< std::complex< float > >(), and Eigen::internal::apply_rotation_in_the_plane_selector< Scalar, OtherScalar, SizeAtCompileTime, MinAlignment, true >::run().

Here is the caller graph for this function:

pstoreu< double >() [1/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< double >	(	double *	to,
		const Packet2d &	from
	)

{ EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_pd(to, from); }

References EIGEN_DEBUG_UNALIGNED_STORE.

pstoreu< double >() [2/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< double >	(	double *	to,
		const Packet2d &	from
	)

{ pstore<double>(to, from); }

References pstore< double >().

Here is the call graph for this function:

pstoreu< double >() [3/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< double >	(	double *	to,
		const Packet4d &	from
	)

{ EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_pd(to, from); }

References EIGEN_DEBUG_UNALIGNED_STORE.

pstoreu< double >() [4/4]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< double >	(	double *	to,
		const Packet8d &	from
	)

                                                                           {
  EIGEN_DEBUG_UNALIGNED_STORE _mm512_storeu_pd(to, from);
}

References EIGEN_DEBUG_UNALIGNED_STORE.

pstoreu< float >() [1/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float >	(	float *	to,
		const Packet16f &	from
	)

                                                                          {
  EIGEN_DEBUG_UNALIGNED_STORE _mm512_storeu_ps(to, from);
}

References EIGEN_DEBUG_UNALIGNED_STORE.

pstoreu< float >() [2/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float >	(	float *	to,
		const Packet4f &	from
	)

{
  EIGEN_DEBUG_ALIGNED_STORE
  vec_vsx_st(from, (long)to & 15, (float*) _EIGEN_ALIGNED_PTR(to));
}

References _EIGEN_ALIGNED_PTR, and EIGEN_DEBUG_ALIGNED_STORE.

pstoreu< float >() [3/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float >	(	float *	to,
		const Packet4f &	from
	)

{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_f32(to, from); }

References EIGEN_DEBUG_UNALIGNED_STORE.

pstoreu< float >() [4/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float >	(	float *	to,
		const Packet4f &	from
	)

{ EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_ps(to, from); }

References EIGEN_DEBUG_UNALIGNED_STORE.

pstoreu< float >() [5/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float >	(	float *	to,
		const Packet4f &	from
	)

{ pstore<float>(to, from); }

References pstore< float >().

Here is the call graph for this function:

pstoreu< float >() [6/6]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float >	(	float *	to,
		const Packet8f &	from
	)

{ EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_ps(to, from); }

References EIGEN_DEBUG_UNALIGNED_STORE.

pstoreu< int >() [1/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int >	(	int *	to,
		const Packet16i &	from
	)

                                                                      {
  EIGEN_DEBUG_UNALIGNED_STORE _mm512_storeu_si512(
      reinterpret_cast<__m512i*>(to), from);
}

References EIGEN_DEBUG_UNALIGNED_STORE.

pstoreu< int >() [2/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int >	(	int *	to,
		const Packet4i &	from
	)

{
  EIGEN_DEBUG_ALIGNED_STORE
  vec_vsx_st(from, (long)to & 15, (int*) _EIGEN_ALIGNED_PTR(to));
}

References _EIGEN_ALIGNED_PTR, and EIGEN_DEBUG_ALIGNED_STORE.

pstoreu< int >() [3/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int >	(	int *	to,
		const Packet4i &	from
	)

{ EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_si128(reinterpret_cast<__m128i*>(to), from); }

References EIGEN_DEBUG_UNALIGNED_STORE.

pstoreu< int >() [4/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int >	(	int *	to,
		const Packet4i &	from
	)

{ pstore<int>(to, from); }

References pstore< int >().

Here is the call graph for this function:

pstoreu< int >() [5/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int >	(	int *	to,
		const Packet8i &	from
	)

{ EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_si256(reinterpret_cast<__m256i*>(to), from); }

References EIGEN_DEBUG_UNALIGNED_STORE.

pstoreu< int32_t >()

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int32_t >	(	int32_t *	to,
		const Packet4i &	from
	)

{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_s32(to, from); }

References EIGEN_DEBUG_UNALIGNED_STORE.

pstoreu< std::complex< double > >() [1/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< double > >	(	std::complex< double > *	to,
		const Packet1cd &	from
	)

{ EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, Packet2d(from.v)); }

References EIGEN_DEBUG_UNALIGNED_STORE, and pstoreu().

Here is the call graph for this function:

pstoreu< std::complex< double > >() [2/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< double > >	(	std::complex< double > *	to,
		const Packet1cd &	from
	)

{ EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, from.v); }

References EIGEN_DEBUG_UNALIGNED_STORE, and pstoreu().

Here is the call graph for this function:

pstoreu< std::complex< double > >() [3/3]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< double > >	(	std::complex< double > *	to,
		const Packet2cd &	from
	)

{ EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, from.v); }

References EIGEN_DEBUG_UNALIGNED_STORE, and pstoreu().

Here is the call graph for this function:

pstoreu< std::complex< float > >() [1/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

{ pstoreu((float*)to, from.v); }

References pstoreu().

Here is the call graph for this function:

pstoreu< std::complex< float > >() [2/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

{ EIGEN_DEBUG_UNALIGNED_STORE pstoreu((float*)to, from.v); }

References EIGEN_DEBUG_UNALIGNED_STORE, and pstoreu().

Here is the call graph for this function:

pstoreu< std::complex< float > >() [3/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

{ EIGEN_DEBUG_UNALIGNED_STORE pstoreu(&numext::real_ref(*to), Packet4f(from.v)); }

References EIGEN_DEBUG_UNALIGNED_STORE, pstoreu(), and Eigen::numext::real_ref().

Here is the call graph for this function:

pstoreu< std::complex< float > >() [4/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< float > >	(	std::complex< float > *	to,
		const Packet2cf &	from
	)

{ EIGEN_DEBUG_UNALIGNED_STORE pstoreu((float*)to, from.v); }

References EIGEN_DEBUG_UNALIGNED_STORE, and pstoreu().

Here is the call graph for this function:

pstoreu< std::complex< float > >() [5/5]

template<>

EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< float > >	(	std::complex< float > *	to,
		const Packet4cf &	from
	)

{ EIGEN_DEBUG_UNALIGNED_STORE pstoreu(&numext::real_ref(*to), from.v); }

References EIGEN_DEBUG_UNALIGNED_STORE, pstoreu(), and Eigen::numext::real_ref().

Here is the call graph for this function:

psub()

template<typename Packet >

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

inline

                         { return a-b; }

Referenced by Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs >::acc(), Eigen::internal::sub_assign_op< DstScalar, SrcScalar >::assignPacket(), Eigen::internal::scalar_difference_op< LhsScalar, RhsScalar >::packetOp(), pcos< Packet4f >(), pexp< Packet2d >(), pexp< Packet4d >(), pexp< Packet4f >(), pexp< Packet8f >(), plog< Packet4f >(), plog< Packet8f >(), pnegate(), psin< Packet4f >(), psin< Packet8f >(), Eigen::internal::quat_product< Architecture::SSE, Derived, OtherDerived, double >::run(), and Eigen::internal::apply_rotation_in_the_plane_selector< Scalar, OtherScalar, SizeAtCompileTime, MinAlignment, true >::run().

Here is the caller graph for this function:

psub< Packet16f >()

template<>

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

                                                                  {
  return _mm512_sub_ps(a, b);
}

psub< Packet1cd >() [1/2]

template<>

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

{ return Packet1cd(_mm_sub_pd(a.v,b.v)); }

psub< Packet1cd >() [2/2]

template<>

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

{ return Packet1cd(a.v - b.v); }

psub< Packet2cd >()

template<>

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

{ return Packet2cd(_mm256_sub_pd(a.v,b.v)); }

psub< Packet2cf >() [1/4]

template<>

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

{ return Packet2cf(a.v - b.v); }

psub< Packet2cf >() [2/4]

template<>

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

{ return Packet2cf(psub<Packet4f>(a.v,b.v)); }

References psub< Packet4f >().

Here is the call graph for this function:

psub< Packet2cf >() [3/4]

template<>

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

{ return Packet2cf(_mm_sub_ps(a.v,b.v)); }

psub< Packet2cf >() [4/4]

template<>

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

{ return Packet2cf(psub<Packet4f>(a.v, b.v)); }

References psub< Packet4f >().

Here is the call graph for this function:

psub< Packet2d >() [1/2]

template<>

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

{ return _mm_sub_pd(a,b); }

psub< Packet2d >() [2/2]

template<>

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

{ return (a - b); }

psub< Packet4cf >()

template<>

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

{ return Packet4cf(_mm256_sub_ps(a.v,b.v)); }

psub< Packet4d >()

template<>

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

{ return _mm256_sub_pd(a,b); }

psub< Packet4f >() [1/4]

template<>

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

{ return a - b; }

Referenced by psub< Packet2cf >().

Here is the caller graph for this function:

psub< Packet4f >() [2/4]

template<>

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

{ return vsubq_f32(a,b); }

psub< Packet4f >() [3/4]

template<>

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

{ return _mm_sub_ps(a,b); }

psub< Packet4f >() [4/4]

template<>

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

{
  Packet4f c;
  c.v4f[0] = a.v4f[0] - b.v4f[0];
  c.v4f[1] = a.v4f[1] - b.v4f[1];
  return c;
}

psub< Packet4i >() [1/4]

template<>

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

{ return a - b; }

psub< Packet4i >() [2/4]

template<>

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

{ return vsubq_s32(a,b); }

psub< Packet4i >() [3/4]

template<>

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

{ return _mm_sub_epi32(a,b); }

psub< Packet4i >() [4/4]

template<>

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

{ return (a - b); }

psub< Packet8d >()

template<>

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

                                                               {
  return _mm512_sub_pd(a, b);
}

psub< Packet8f >()

template<>

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

{ return _mm256_sub_ps(a,b); }

ptan()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::ptan

(

const Packet &

a

)

{ using std::tan; return tan(a); }

References tan().

Here is the call graph for this function:

ptanh()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::ptanh

(

const Packet &

a

)

{ using std::tanh; return tanh(a); }

References tanh().

Referenced by Eigen::internal::scalar_tanh_op< Scalar >::packetOp().

Here is the call graph for this function:

Here is the caller graph for this function:

ptanh< Packet4f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f Eigen::internal::ptanh< Packet4f >

(

const Packet4f &

x

)

                                   {
  return internal::generic_fast_tanh_float(x);
}

References generic_fast_tanh_float().

Here is the call graph for this function:

ptanh< Packet8f >()

template<>

EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f Eigen::internal::ptanh< Packet8f >

(

const Packet8f &

x

)

                                   {
  return internal::generic_fast_tanh_float(x);
}

References generic_fast_tanh_float().

Here is the call graph for this function:

ptranspose() [1/15]

template<typename Packet >

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet, 1 > &  )

inline

                                     {
  // Nothing to do in the scalar case, i.e. a 1x1 matrix.
}

ptranspose() [2/15]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet16f, 16 > &  kernel )

inline

                                                                             {
  __m512 T0 = _mm512_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
  __m512 T1 = _mm512_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
  __m512 T2 = _mm512_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
  __m512 T3 = _mm512_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
  __m512 T4 = _mm512_unpacklo_ps(kernel.packet[4], kernel.packet[5]);
  __m512 T5 = _mm512_unpackhi_ps(kernel.packet[4], kernel.packet[5]);
  __m512 T6 = _mm512_unpacklo_ps(kernel.packet[6], kernel.packet[7]);
  __m512 T7 = _mm512_unpackhi_ps(kernel.packet[6], kernel.packet[7]);
  __m512 T8 = _mm512_unpacklo_ps(kernel.packet[8], kernel.packet[9]);
  __m512 T9 = _mm512_unpackhi_ps(kernel.packet[8], kernel.packet[9]);
  __m512 T10 = _mm512_unpacklo_ps(kernel.packet[10], kernel.packet[11]);
  __m512 T11 = _mm512_unpackhi_ps(kernel.packet[10], kernel.packet[11]);
  __m512 T12 = _mm512_unpacklo_ps(kernel.packet[12], kernel.packet[13]);
  __m512 T13 = _mm512_unpackhi_ps(kernel.packet[12], kernel.packet[13]);
  __m512 T14 = _mm512_unpacklo_ps(kernel.packet[14], kernel.packet[15]);
  __m512 T15 = _mm512_unpackhi_ps(kernel.packet[14], kernel.packet[15]);
  __m512 S0 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(1, 0, 1, 0));
  __m512 S1 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(3, 2, 3, 2));
  __m512 S2 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(1, 0, 1, 0));
  __m512 S3 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(3, 2, 3, 2));
  __m512 S4 = _mm512_shuffle_ps(T4, T6, _MM_SHUFFLE(1, 0, 1, 0));
  __m512 S5 = _mm512_shuffle_ps(T4, T6, _MM_SHUFFLE(3, 2, 3, 2));
  __m512 S6 = _mm512_shuffle_ps(T5, T7, _MM_SHUFFLE(1, 0, 1, 0));
  __m512 S7 = _mm512_shuffle_ps(T5, T7, _MM_SHUFFLE(3, 2, 3, 2));
  __m512 S8 = _mm512_shuffle_ps(T8, T10, _MM_SHUFFLE(1, 0, 1, 0));
  __m512 S9 = _mm512_shuffle_ps(T8, T10, _MM_SHUFFLE(3, 2, 3, 2));
  __m512 S10 = _mm512_shuffle_ps(T9, T11, _MM_SHUFFLE(1, 0, 1, 0));
  __m512 S11 = _mm512_shuffle_ps(T9, T11, _MM_SHUFFLE(3, 2, 3, 2));
  __m512 S12 = _mm512_shuffle_ps(T12, T14, _MM_SHUFFLE(1, 0, 1, 0));
  __m512 S13 = _mm512_shuffle_ps(T12, T14, _MM_SHUFFLE(3, 2, 3, 2));
  __m512 S14 = _mm512_shuffle_ps(T13, T15, _MM_SHUFFLE(1, 0, 1, 0));
  __m512 S15 = _mm512_shuffle_ps(T13, T15, _MM_SHUFFLE(3, 2, 3, 2));
 
  EIGEN_EXTRACT_8f_FROM_16f(S0, S0);
  EIGEN_EXTRACT_8f_FROM_16f(S1, S1);
  EIGEN_EXTRACT_8f_FROM_16f(S2, S2);
  EIGEN_EXTRACT_8f_FROM_16f(S3, S3);
  EIGEN_EXTRACT_8f_FROM_16f(S4, S4);
  EIGEN_EXTRACT_8f_FROM_16f(S5, S5);
  EIGEN_EXTRACT_8f_FROM_16f(S6, S6);
  EIGEN_EXTRACT_8f_FROM_16f(S7, S7);
  EIGEN_EXTRACT_8f_FROM_16f(S8, S8);
  EIGEN_EXTRACT_8f_FROM_16f(S9, S9);
  EIGEN_EXTRACT_8f_FROM_16f(S10, S10);
  EIGEN_EXTRACT_8f_FROM_16f(S11, S11);
  EIGEN_EXTRACT_8f_FROM_16f(S12, S12);
  EIGEN_EXTRACT_8f_FROM_16f(S13, S13);
  EIGEN_EXTRACT_8f_FROM_16f(S14, S14);
  EIGEN_EXTRACT_8f_FROM_16f(S15, S15);
 
  PacketBlock<Packet8f, 32> tmp;
 
  tmp.packet[0] = _mm256_permute2f128_ps(S0_0, S4_0, 0x20);
  tmp.packet[1] = _mm256_permute2f128_ps(S1_0, S5_0, 0x20);
  tmp.packet[2] = _mm256_permute2f128_ps(S2_0, S6_0, 0x20);
  tmp.packet[3] = _mm256_permute2f128_ps(S3_0, S7_0, 0x20);
  tmp.packet[4] = _mm256_permute2f128_ps(S0_0, S4_0, 0x31);
  tmp.packet[5] = _mm256_permute2f128_ps(S1_0, S5_0, 0x31);
  tmp.packet[6] = _mm256_permute2f128_ps(S2_0, S6_0, 0x31);
  tmp.packet[7] = _mm256_permute2f128_ps(S3_0, S7_0, 0x31);
 
  tmp.packet[8] = _mm256_permute2f128_ps(S0_1, S4_1, 0x20);
  tmp.packet[9] = _mm256_permute2f128_ps(S1_1, S5_1, 0x20);
  tmp.packet[10] = _mm256_permute2f128_ps(S2_1, S6_1, 0x20);
  tmp.packet[11] = _mm256_permute2f128_ps(S3_1, S7_1, 0x20);
  tmp.packet[12] = _mm256_permute2f128_ps(S0_1, S4_1, 0x31);
  tmp.packet[13] = _mm256_permute2f128_ps(S1_1, S5_1, 0x31);
  tmp.packet[14] = _mm256_permute2f128_ps(S2_1, S6_1, 0x31);
  tmp.packet[15] = _mm256_permute2f128_ps(S3_1, S7_1, 0x31);
 
  // Second set of _m256 outputs
  tmp.packet[16] = _mm256_permute2f128_ps(S8_0, S12_0, 0x20);
  tmp.packet[17] = _mm256_permute2f128_ps(S9_0, S13_0, 0x20);
  tmp.packet[18] = _mm256_permute2f128_ps(S10_0, S14_0, 0x20);
  tmp.packet[19] = _mm256_permute2f128_ps(S11_0, S15_0, 0x20);
  tmp.packet[20] = _mm256_permute2f128_ps(S8_0, S12_0, 0x31);
  tmp.packet[21] = _mm256_permute2f128_ps(S9_0, S13_0, 0x31);
  tmp.packet[22] = _mm256_permute2f128_ps(S10_0, S14_0, 0x31);
  tmp.packet[23] = _mm256_permute2f128_ps(S11_0, S15_0, 0x31);
 
  tmp.packet[24] = _mm256_permute2f128_ps(S8_1, S12_1, 0x20);
  tmp.packet[25] = _mm256_permute2f128_ps(S9_1, S13_1, 0x20);
  tmp.packet[26] = _mm256_permute2f128_ps(S10_1, S14_1, 0x20);
  tmp.packet[27] = _mm256_permute2f128_ps(S11_1, S15_1, 0x20);
  tmp.packet[28] = _mm256_permute2f128_ps(S8_1, S12_1, 0x31);
  tmp.packet[29] = _mm256_permute2f128_ps(S9_1, S13_1, 0x31);
  tmp.packet[30] = _mm256_permute2f128_ps(S10_1, S14_1, 0x31);
  tmp.packet[31] = _mm256_permute2f128_ps(S11_1, S15_1, 0x31);
 
  // Pack them into the output
  PACK_OUTPUT(kernel.packet, tmp.packet, 0, 16);
  PACK_OUTPUT(kernel.packet, tmp.packet, 1, 16);
  PACK_OUTPUT(kernel.packet, tmp.packet, 2, 16);
  PACK_OUTPUT(kernel.packet, tmp.packet, 3, 16);
 
  PACK_OUTPUT(kernel.packet, tmp.packet, 4, 16);
  PACK_OUTPUT(kernel.packet, tmp.packet, 5, 16);
  PACK_OUTPUT(kernel.packet, tmp.packet, 6, 16);
  PACK_OUTPUT(kernel.packet, tmp.packet, 7, 16);
 
  PACK_OUTPUT(kernel.packet, tmp.packet, 8, 16);
  PACK_OUTPUT(kernel.packet, tmp.packet, 9, 16);
  PACK_OUTPUT(kernel.packet, tmp.packet, 10, 16);
  PACK_OUTPUT(kernel.packet, tmp.packet, 11, 16);
 
  PACK_OUTPUT(kernel.packet, tmp.packet, 12, 16);
  PACK_OUTPUT(kernel.packet, tmp.packet, 13, 16);
  PACK_OUTPUT(kernel.packet, tmp.packet, 14, 16);
  PACK_OUTPUT(kernel.packet, tmp.packet, 15, 16);
}

References EIGEN_EXTRACT_8f_FROM_16f, PACK_OUTPUT, and Eigen::internal::PacketBlock< Packet, N >::packet.

ptranspose() [3/15]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet16f, 4 > &  kernel )

inline

                                                                            {
  __m512 T0 = _mm512_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
  __m512 T1 = _mm512_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
  __m512 T2 = _mm512_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
  __m512 T3 = _mm512_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
 
  __m512 S0 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(1, 0, 1, 0));
  __m512 S1 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(3, 2, 3, 2));
  __m512 S2 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(1, 0, 1, 0));
  __m512 S3 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(3, 2, 3, 2));
 
  EIGEN_EXTRACT_8f_FROM_16f(S0, S0);
  EIGEN_EXTRACT_8f_FROM_16f(S1, S1);
  EIGEN_EXTRACT_8f_FROM_16f(S2, S2);
  EIGEN_EXTRACT_8f_FROM_16f(S3, S3);
 
  PacketBlock<Packet8f, 8> tmp;
 
  tmp.packet[0] = _mm256_permute2f128_ps(S0_0, S1_0, 0x20);
  tmp.packet[1] = _mm256_permute2f128_ps(S2_0, S3_0, 0x20);
  tmp.packet[2] = _mm256_permute2f128_ps(S0_0, S1_0, 0x31);
  tmp.packet[3] = _mm256_permute2f128_ps(S2_0, S3_0, 0x31);
 
  tmp.packet[4] = _mm256_permute2f128_ps(S0_1, S1_1, 0x20);
  tmp.packet[5] = _mm256_permute2f128_ps(S2_1, S3_1, 0x20);
  tmp.packet[6] = _mm256_permute2f128_ps(S0_1, S1_1, 0x31);
  tmp.packet[7] = _mm256_permute2f128_ps(S2_1, S3_1, 0x31);
 
  PACK_OUTPUT_2(kernel.packet, tmp.packet, 0, 1);
  PACK_OUTPUT_2(kernel.packet, tmp.packet, 1, 1);
  PACK_OUTPUT_2(kernel.packet, tmp.packet, 2, 1);
  PACK_OUTPUT_2(kernel.packet, tmp.packet, 3, 1);
}

References EIGEN_EXTRACT_8f_FROM_16f, PACK_OUTPUT_2, and Eigen::internal::PacketBlock< Packet, N >::packet.

ptranspose() [4/15]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose

(

PacketBlock< Packet1cd, 2 > &

kernel

)

{
  Packet2d tmp = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_HI);
  kernel.packet[1].v = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_LO);
  kernel.packet[0].v = tmp;
}

References p16uc_TRANSPOSE64_HI, p16uc_TRANSPOSE64_LO, and Eigen::internal::PacketBlock< Packet, N >::packet.

ptranspose() [5/15]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet2cd, 2 > &  kernel )

inline

                                             {
  __m256d tmp = _mm256_permute2f128_pd(kernel.packet[0].v, kernel.packet[1].v, 0+(2<<4));
  kernel.packet[1].v = _mm256_permute2f128_pd(kernel.packet[0].v, kernel.packet[1].v, 1+(3<<4));
 kernel.packet[0].v = tmp;
}

References Eigen::internal::PacketBlock< Packet, N >::packet.

ptranspose() [6/15]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet2cf, 2 > &  kernel )

inline

{
  Packet4f tmp = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_HI);
  kernel.packet[1].v = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_LO);
  kernel.packet[0].v = tmp;
}

References p16uc_TRANSPOSE64_HI, p16uc_TRANSPOSE64_LO, and Eigen::internal::PacketBlock< Packet, N >::packet.

Referenced by Eigen::internal::gemm_pack_lhs< Scalar, Index, DataMapper, Pack1, Pack2, RowMajor, Conjugate, PanelMode >::operator()(), Eigen::internal::gemm_pack_rhs< Scalar, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode >::operator()(), preduxp< Packet2cf >(), preduxp< Packet4f >(), and Eigen::internal::inplace_transpose_selector< MatrixType, true, true >::run().

Here is the caller graph for this function:

ptranspose() [7/15]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet2d, 2 > &  kernel )

inline

                                            {
  __m128d tmp = _mm_unpackhi_pd(kernel.packet[0], kernel.packet[1]);
  kernel.packet[0] = _mm_unpacklo_pd(kernel.packet[0], kernel.packet[1]);
  kernel.packet[1] = tmp;
}

References Eigen::internal::PacketBlock< Packet, N >::packet.

ptranspose() [8/15]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet4cf, 4 > &  kernel )

inline

                                             {
  __m256d P0 = _mm256_castps_pd(kernel.packet[0].v);
  __m256d P1 = _mm256_castps_pd(kernel.packet[1].v);
  __m256d P2 = _mm256_castps_pd(kernel.packet[2].v);
  __m256d P3 = _mm256_castps_pd(kernel.packet[3].v);
 
  __m256d T0 = _mm256_shuffle_pd(P0, P1, 15);
  __m256d T1 = _mm256_shuffle_pd(P0, P1, 0);
  __m256d T2 = _mm256_shuffle_pd(P2, P3, 15);
  __m256d T3 = _mm256_shuffle_pd(P2, P3, 0);
 
  kernel.packet[1].v = _mm256_castpd_ps(_mm256_permute2f128_pd(T0, T2, 32));
  kernel.packet[3].v = _mm256_castpd_ps(_mm256_permute2f128_pd(T0, T2, 49));
  kernel.packet[0].v = _mm256_castpd_ps(_mm256_permute2f128_pd(T1, T3, 32));
  kernel.packet[2].v = _mm256_castpd_ps(_mm256_permute2f128_pd(T1, T3, 49));
}

References Eigen::internal::PacketBlock< Packet, N >::packet.

ptranspose() [9/15]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet4d, 4 > &  kernel )

inline

                                            {
  __m256d T0 = _mm256_shuffle_pd(kernel.packet[0], kernel.packet[1], 15);
  __m256d T1 = _mm256_shuffle_pd(kernel.packet[0], kernel.packet[1], 0);
  __m256d T2 = _mm256_shuffle_pd(kernel.packet[2], kernel.packet[3], 15);
  __m256d T3 = _mm256_shuffle_pd(kernel.packet[2], kernel.packet[3], 0);
 
  kernel.packet[1] = _mm256_permute2f128_pd(T0, T2, 32);
  kernel.packet[3] = _mm256_permute2f128_pd(T0, T2, 49);
  kernel.packet[0] = _mm256_permute2f128_pd(T1, T3, 32);
  kernel.packet[2] = _mm256_permute2f128_pd(T1, T3, 49);
}

References Eigen::internal::PacketBlock< Packet, N >::packet.

ptranspose() [10/15]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet4f, 4 > &  kernel )

inline

                                            {
  Packet4f t0, t1, t2, t3;
  t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
  t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
  t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
  t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
  kernel.packet[0] = vec_mergeh(t0, t2);
  kernel.packet[1] = vec_mergel(t0, t2);
  kernel.packet[2] = vec_mergeh(t1, t3);
  kernel.packet[3] = vec_mergel(t1, t3);
}

References Eigen::internal::PacketBlock< Packet, N >::packet.

ptranspose() [11/15]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet4i, 4 > &  kernel )

inline

                                            {
  Packet4i t0, t1, t2, t3;
  t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
  t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
  t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
  t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
  kernel.packet[0] = vec_mergeh(t0, t2);
  kernel.packet[1] = vec_mergel(t0, t2);
  kernel.packet[2] = vec_mergeh(t1, t3);
  kernel.packet[3] = vec_mergel(t1, t3);
}

References Eigen::internal::PacketBlock< Packet, N >::packet.

ptranspose() [12/15]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet8d, 4 > &  kernel )

inline

                                                                           {
  __m512d T0 = _mm512_shuffle_pd(kernel.packet[0], kernel.packet[1], 0);
  __m512d T1 = _mm512_shuffle_pd(kernel.packet[0], kernel.packet[1], 0xff);
  __m512d T2 = _mm512_shuffle_pd(kernel.packet[2], kernel.packet[3], 0);
  __m512d T3 = _mm512_shuffle_pd(kernel.packet[2], kernel.packet[3], 0xff);
 
  PacketBlock<Packet4d, 8> tmp;
 
  tmp.packet[0] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 0),
                                         _mm512_extractf64x4_pd(T2, 0), 0x20);
  tmp.packet[1] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 0),
                                         _mm512_extractf64x4_pd(T3, 0), 0x20);
  tmp.packet[2] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 0),
                                         _mm512_extractf64x4_pd(T2, 0), 0x31);
  tmp.packet[3] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 0),
                                         _mm512_extractf64x4_pd(T3, 0), 0x31);
 
  tmp.packet[4] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 1),
                                         _mm512_extractf64x4_pd(T2, 1), 0x20);
  tmp.packet[5] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 1),
                                         _mm512_extractf64x4_pd(T3, 1), 0x20);
  tmp.packet[6] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 1),
                                         _mm512_extractf64x4_pd(T2, 1), 0x31);
  tmp.packet[7] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 1),
                                         _mm512_extractf64x4_pd(T3, 1), 0x31);
 
  PACK_OUTPUT_D(kernel.packet, tmp.packet, 0, 1);
  PACK_OUTPUT_D(kernel.packet, tmp.packet, 1, 1);
  PACK_OUTPUT_D(kernel.packet, tmp.packet, 2, 1);
  PACK_OUTPUT_D(kernel.packet, tmp.packet, 3, 1);
}

References PACK_OUTPUT_D, and Eigen::internal::PacketBlock< Packet, N >::packet.

ptranspose() [13/15]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet8d, 8 > &  kernel )

inline

                                                                           {
  __m512d T0 = _mm512_unpacklo_pd(kernel.packet[0], kernel.packet[1]);
  __m512d T1 = _mm512_unpackhi_pd(kernel.packet[0], kernel.packet[1]);
  __m512d T2 = _mm512_unpacklo_pd(kernel.packet[2], kernel.packet[3]);
  __m512d T3 = _mm512_unpackhi_pd(kernel.packet[2], kernel.packet[3]);
  __m512d T4 = _mm512_unpacklo_pd(kernel.packet[4], kernel.packet[5]);
  __m512d T5 = _mm512_unpackhi_pd(kernel.packet[4], kernel.packet[5]);
  __m512d T6 = _mm512_unpacklo_pd(kernel.packet[6], kernel.packet[7]);
  __m512d T7 = _mm512_unpackhi_pd(kernel.packet[6], kernel.packet[7]);
 
  PacketBlock<Packet4d, 16> tmp;
 
  tmp.packet[0] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 0),
                                         _mm512_extractf64x4_pd(T2, 0), 0x20);
  tmp.packet[1] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 0),
                                         _mm512_extractf64x4_pd(T3, 0), 0x20);
  tmp.packet[2] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 0),
                                         _mm512_extractf64x4_pd(T2, 0), 0x31);
  tmp.packet[3] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 0),
                                         _mm512_extractf64x4_pd(T3, 0), 0x31);
 
  tmp.packet[4] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 1),
                                         _mm512_extractf64x4_pd(T2, 1), 0x20);
  tmp.packet[5] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 1),
                                         _mm512_extractf64x4_pd(T3, 1), 0x20);
  tmp.packet[6] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 1),
                                         _mm512_extractf64x4_pd(T2, 1), 0x31);
  tmp.packet[7] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 1),
                                         _mm512_extractf64x4_pd(T3, 1), 0x31);
 
  tmp.packet[8] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T4, 0),
                                         _mm512_extractf64x4_pd(T6, 0), 0x20);
  tmp.packet[9] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T5, 0),
                                         _mm512_extractf64x4_pd(T7, 0), 0x20);
  tmp.packet[10] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T4, 0),
                                          _mm512_extractf64x4_pd(T6, 0), 0x31);
  tmp.packet[11] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T5, 0),
                                          _mm512_extractf64x4_pd(T7, 0), 0x31);
 
  tmp.packet[12] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T4, 1),
                                          _mm512_extractf64x4_pd(T6, 1), 0x20);
  tmp.packet[13] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T5, 1),
                                          _mm512_extractf64x4_pd(T7, 1), 0x20);
  tmp.packet[14] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T4, 1),
                                          _mm512_extractf64x4_pd(T6, 1), 0x31);
  tmp.packet[15] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T5, 1),
                                          _mm512_extractf64x4_pd(T7, 1), 0x31);
 
  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 0, 8);
  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 1, 8);
  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 2, 8);
  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 3, 8);
 
  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 4, 8);
  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 5, 8);
  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 6, 8);
  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 7, 8);
}

References PACK_OUTPUT_SQ_D, and Eigen::internal::PacketBlock< Packet, N >::packet.

ptranspose() [14/15]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet8f, 4 > &  kernel )

inline

                                            {
  __m256 T0 = _mm256_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
  __m256 T1 = _mm256_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
  __m256 T2 = _mm256_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
  __m256 T3 = _mm256_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
 
  __m256 S0 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(1,0,1,0));
  __m256 S1 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(3,2,3,2));
  __m256 S2 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(1,0,1,0));
  __m256 S3 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(3,2,3,2));
 
  kernel.packet[0] = _mm256_permute2f128_ps(S0, S1, 0x20);
  kernel.packet[1] = _mm256_permute2f128_ps(S2, S3, 0x20);
  kernel.packet[2] = _mm256_permute2f128_ps(S0, S1, 0x31);
  kernel.packet[3] = _mm256_permute2f128_ps(S2, S3, 0x31);
}

References Eigen::internal::PacketBlock< Packet, N >::packet.

ptranspose() [15/15]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet8f, 8 > &  kernel )

inline

                                            {
  __m256 T0 = _mm256_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
  __m256 T1 = _mm256_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
  __m256 T2 = _mm256_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
  __m256 T3 = _mm256_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
  __m256 T4 = _mm256_unpacklo_ps(kernel.packet[4], kernel.packet[5]);
  __m256 T5 = _mm256_unpackhi_ps(kernel.packet[4], kernel.packet[5]);
  __m256 T6 = _mm256_unpacklo_ps(kernel.packet[6], kernel.packet[7]);
  __m256 T7 = _mm256_unpackhi_ps(kernel.packet[6], kernel.packet[7]);
  __m256 S0 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(1,0,1,0));
  __m256 S1 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(3,2,3,2));
  __m256 S2 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(1,0,1,0));
  __m256 S3 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(3,2,3,2));
  __m256 S4 = _mm256_shuffle_ps(T4,T6,_MM_SHUFFLE(1,0,1,0));
  __m256 S5 = _mm256_shuffle_ps(T4,T6,_MM_SHUFFLE(3,2,3,2));
  __m256 S6 = _mm256_shuffle_ps(T5,T7,_MM_SHUFFLE(1,0,1,0));
  __m256 S7 = _mm256_shuffle_ps(T5,T7,_MM_SHUFFLE(3,2,3,2));
  kernel.packet[0] = _mm256_permute2f128_ps(S0, S4, 0x20);
  kernel.packet[1] = _mm256_permute2f128_ps(S1, S5, 0x20);
  kernel.packet[2] = _mm256_permute2f128_ps(S2, S6, 0x20);
  kernel.packet[3] = _mm256_permute2f128_ps(S3, S7, 0x20);
  kernel.packet[4] = _mm256_permute2f128_ps(S0, S4, 0x31);
  kernel.packet[5] = _mm256_permute2f128_ps(S1, S5, 0x31);
  kernel.packet[6] = _mm256_permute2f128_ps(S2, S6, 0x31);
  kernel.packet[7] = _mm256_permute2f128_ps(S3, S7, 0x31);
}

References Eigen::internal::PacketBlock< Packet, N >::packet.

punpackp()

EIGEN_STRONG_INLINE void Eigen::internal::punpackp

(

Packet4f *

vecs

)

{
  vecs[1] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0x55));
  vecs[2] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0xAA));
  vecs[3] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0xFF));
  vecs[0] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0x00));
}

putMarketHeader()

template<typename Scalar >

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

inline

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

References Eigen::SelfAdjoint, and Eigen::Symmetric.

PutMatrixElt() [1/2]

template<typename Scalar >

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

inline

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

References col(), and row().

Referenced by Eigen::saveMarket().

Here is the call graph for this function:

Here is the caller graph for this function:

PutMatrixElt() [2/2]

template<typename Scalar >

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

inline

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

References col(), and row().

Here is the call graph for this function:

putVectorElt() [1/2]

template<typename Scalar >

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

inline

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

Referenced by Eigen::saveMarketVector().

Here is the caller graph for this function:

putVectorElt() [2/2]

template<typename Scalar >

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

inline

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

pxor()

template<typename Packet >

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

inline

{ return a ^ b; }

Referenced by pmul< Packet2cf >(), and Eigen::internal::quat_product< Architecture::SSE, Derived, OtherDerived, double >::run().

Here is the caller graph for this function:

pxor< Packet16f >()

template<>

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

                                                                  {
#ifdef EIGEN_VECTORIZE_AVX512DQ
  return _mm512_xor_ps(a, b);
#else
  Packet16f res = _mm512_undefined_ps();
  Packet4f lane0_a = _mm512_extractf32x4_ps(a, 0);
  Packet4f lane0_b = _mm512_extractf32x4_ps(b, 0);
  res = _mm512_insertf32x4(res, _mm_xor_ps(lane0_a, lane0_b), 0);
 
  Packet4f lane1_a = _mm512_extractf32x4_ps(a, 1);
  Packet4f lane1_b = _mm512_extractf32x4_ps(b, 1);
  res = _mm512_insertf32x4(res, _mm_xor_ps(lane1_a, lane1_b), 1);
 
  Packet4f lane2_a = _mm512_extractf32x4_ps(a, 2);
  Packet4f lane2_b = _mm512_extractf32x4_ps(b, 2);
  res = _mm512_insertf32x4(res, _mm_xor_ps(lane2_a, lane2_b), 2);
 
  Packet4f lane3_a = _mm512_extractf32x4_ps(a, 3);
  Packet4f lane3_b = _mm512_extractf32x4_ps(b, 3);
  res = _mm512_insertf32x4(res, _mm_xor_ps(lane3_a, lane3_b), 3);
 
  return res;
#endif
}

pxor< Packet1cd >() [1/2]

template<>

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

{ return Packet1cd(_mm_xor_pd(a.v,b.v)); }

pxor< Packet1cd >() [2/2]

template<>

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

{ return Packet1cd(vec_xor(a.v,b.v)); }

pxor< Packet2cd >()

template<>

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

{ return Packet2cd(_mm256_xor_pd(a.v,b.v)); }

pxor< Packet2cf >() [1/4]

template<>

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

{ return Packet2cf(pxor<Packet4f>(a.v, b.v)); }

References pxor< Packet4f >().

Here is the call graph for this function:

pxor< Packet2cf >() [2/4]

template<>

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

{
  return Packet2cf(vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(a.v),vreinterpretq_u32_f32(b.v))));
}

pxor< Packet2cf >() [3/4]

template<>

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

{ return Packet2cf(_mm_xor_ps(a.v,b.v)); }

pxor< Packet2cf >() [4/4]

template<>

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

{ return Packet2cf(pxor<Packet4f>(a.v,b.v)); }

References pxor< Packet4f >().

Here is the call graph for this function:

pxor< Packet2d >() [1/2]

template<>

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

{ return _mm_xor_pd(a,b); }

pxor< Packet2d >() [2/2]

template<>

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

{ return vec_xor(a, b); }

pxor< Packet4cf >()

template<>

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

{ return Packet4cf(_mm256_xor_ps(a.v,b.v)); }

pxor< Packet4d >()

template<>

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

{ return _mm256_xor_pd(a,b); }

pxor< Packet4f >() [1/4]

template<>

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

{ return vec_xor(a, b); }

Referenced by pconj(), and pxor< Packet2cf >().

Here is the caller graph for this function:

pxor< Packet4f >() [2/4]

template<>

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

{
  return vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b)));
}

pxor< Packet4f >() [3/4]

template<>

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

{ return _mm_xor_ps(a,b); }

pxor< Packet4f >() [4/4]

template<>

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

{
  Packet4f res;
  res.v4f[0] = pand(a.v4f[0], b.v4f[0]);
  res.v4f[1] = pand(a.v4f[1], b.v4f[1]);
  return res;
}

References pand(), and Eigen::internal::Packet4f::v4f.

Here is the call graph for this function:

pxor< Packet4i >() [1/4]

template<>

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

{ return vec_xor(a, b); }

pxor< Packet4i >() [2/4]

template<>

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

{ return veorq_s32(a,b); }

pxor< Packet4i >() [3/4]

template<>

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

{ return _mm_xor_si128(a,b); }

pxor< Packet4i >() [4/4]

template<>

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

{ return vec_xor(a, b); }

pxor< Packet8d >()

template<>

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

                                                               {
#ifdef EIGEN_VECTORIZE_AVX512DQ
  return _mm512_xor_pd(a, b);
#else
  Packet8d res = _mm512_undefined_pd();
  Packet4d lane0_a = _mm512_extractf64x4_pd(a, 0);
  Packet4d lane0_b = _mm512_extractf64x4_pd(b, 0);
  res = _mm512_insertf64x4(res, _mm256_xor_pd(lane0_a, lane0_b), 0);
 
  Packet4d lane1_a = _mm512_extractf64x4_pd(a, 1);
  Packet4d lane1_b = _mm512_extractf64x4_pd(b, 1);
  res = _mm512_insertf64x4(res, _mm256_xor_pd(lane1_a, lane1_b), 1);
 
  return res;
#endif
}

pxor< Packet8f >()

template<>

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

{ return _mm256_xor_ps(a,b); }

queryCacheSizes()

void Eigen::internal::queryCacheSizes ( int &  l1, int &  l2, int &  l3  )

inline

{
  #ifdef EIGEN_CPUID
  int abcd[4];
  const int GenuineIntel[] = {0x756e6547, 0x49656e69, 0x6c65746e};
  const int AuthenticAMD[] = {0x68747541, 0x69746e65, 0x444d4163};
  const int AMDisbetter_[] = {0x69444d41, 0x74656273, 0x21726574}; // "AMDisbetter!"
 
  // identify the CPU vendor
  EIGEN_CPUID(abcd,0x0,0);
  int max_std_funcs = abcd[1];
  if(cpuid_is_vendor(abcd,GenuineIntel))
    queryCacheSizes_intel(l1,l2,l3,max_std_funcs);
  else if(cpuid_is_vendor(abcd,AuthenticAMD) || cpuid_is_vendor(abcd,AMDisbetter_))
    queryCacheSizes_amd(l1,l2,l3);
  else
    // by default let's use Intel's API
    queryCacheSizes_intel(l1,l2,l3,max_std_funcs);
 
  // here is the list of other vendors:
//   ||cpuid_is_vendor(abcd,"VIA VIA VIA ")
//   ||cpuid_is_vendor(abcd,"CyrixInstead")
//   ||cpuid_is_vendor(abcd,"CentaurHauls")
//   ||cpuid_is_vendor(abcd,"GenuineTMx86")
//   ||cpuid_is_vendor(abcd,"TransmetaCPU")
//   ||cpuid_is_vendor(abcd,"RiseRiseRise")
//   ||cpuid_is_vendor(abcd,"Geode by NSC")
//   ||cpuid_is_vendor(abcd,"SiS SiS SiS ")
//   ||cpuid_is_vendor(abcd,"UMC UMC UMC ")
//   ||cpuid_is_vendor(abcd,"NexGenDriven")
  #else
  l1 = l2 = l3 = -1;
  #endif
}

Referenced by Eigen::internal::CacheSizes::CacheSizes(), queryL1CacheSize(), and queryTopLevelCacheSize().

Here is the caller graph for this function:

queryL1CacheSize()

int Eigen::internal::queryL1CacheSize ( )

inline

{
  int l1(-1), l2, l3;
  queryCacheSizes(l1,l2,l3);
  return l1;
}

References queryCacheSizes().

Here is the call graph for this function:

queryTopLevelCacheSize()

int Eigen::internal::queryTopLevelCacheSize ( )

inline

{
  int l1, l2(-1), l3(-1);
  queryCacheSizes(l1,l2,l3);
  return (std::max)(l2,l3);
}

References queryCacheSizes().

Here is the call graph for this function:

QuickSplit()

template<typename VectorV , typename VectorI >

Index Eigen::internal::QuickSplit	(	VectorV &	row,
		VectorI &	ind,
		Index	ncut
	)

{
  typedef typename VectorV::RealScalar RealScalar;
  using std::swap;
  using std::abs;
  Index mid;
  Index n = row.size(); /* length of the vector */
  Index first, last ;
  
  ncut--; /* to fit the zero-based indices */
  first = 0; 
  last = n-1; 
  if (ncut < first || ncut > last ) return 0;
  
  do {
    mid = first; 
    RealScalar abskey = abs(row(mid)); 
    for (Index j = first + 1; j <= last; j++) {
      if ( abs(row(j)) > abskey) {
        ++mid;
        swap(row(mid), row(j));
        swap(ind(mid), ind(j));
      }
    }
    /* Interchange for the pivot element */
    swap(row(mid), row(first));
    swap(ind(mid), ind(first));
    
    if (mid > ncut) last = mid - 1;
    else if (mid < ncut ) first = mid + 1; 
  } while (mid != ncut );
  
  return 0; /* mid is equal to ncut */ 
}

References row(), and swap().

Referenced by Eigen::IncompleteLUT< _Scalar, _StorageIndex >::factorize(), and Eigen::IncompleteCholesky< Scalar, _UpLo, _OrderingType >::factorize().

Here is the call graph for this function:

Here is the caller graph for this function:

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.

{
  typedef typename Decomposition::RealScalar RealScalar;
  eigen_assert(dec.rows() == dec.cols());
  if (dec.rows() == 0)              return NumTraits<RealScalar>::infinity();
  if (matrix_norm == RealScalar(0)) return RealScalar(0);
  if (dec.rows() == 1)              return RealScalar(1);
  const RealScalar inverse_matrix_norm = rcond_invmatrix_L1_norm_estimate(dec);
  return (inverse_matrix_norm == RealScalar(0) ? RealScalar(0)
                                               : (RealScalar(1) / inverse_matrix_norm) / matrix_norm);
}

References eigen_assert, and rcond_invmatrix_L1_norm_estimate().

Referenced by Eigen::LDLT< _MatrixType, _UpLo >::rcond(), Eigen::LLT< _MatrixType, _UpLo >::rcond(), Eigen::FullPivLU< _MatrixType >::rcond(), and Eigen::PartialPivLU< _MatrixType >::rcond().

Here is the call graph for this function:

Here is the caller graph for this function:

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.

{
  typedef typename Decomposition::MatrixType MatrixType;
  typedef typename Decomposition::Scalar Scalar;
  typedef typename Decomposition::RealScalar RealScalar;
  typedef typename internal::plain_col_type<MatrixType>::type Vector;
  typedef typename internal::plain_col_type<MatrixType, RealScalar>::type RealVector;
  const bool is_complex = (NumTraits<Scalar>::IsComplex != 0);
 
  eigen_assert(dec.rows() == dec.cols());
  const Index n = dec.rows();
  if (n == 0)
    return 0;
 
  // Disable Index to float conversion warning
#ifdef __INTEL_COMPILER
  #pragma warning push
  #pragma warning ( disable : 2259 )
#endif
  Vector v = dec.solve(Vector::Ones(n) / Scalar(n));
#ifdef __INTEL_COMPILER
  #pragma warning pop
#endif
 
  // lower_bound is a lower bound on
  //   ||inv(matrix)||_1  = sup_v ||inv(matrix) v||_1 / ||v||_1
  // and is the objective maximized by the ("super-") gradient ascent
  // algorithm below.
  RealScalar lower_bound = v.template lpNorm<1>();
  if (n == 1)
    return lower_bound;
 
  // Gradient ascent algorithm follows: We know that the optimum is achieved at
  // one of the simplices v = e_i, so in each iteration we follow a
  // super-gradient to move towards the optimal one.
  RealScalar old_lower_bound = lower_bound;
  Vector sign_vector(n);
  Vector old_sign_vector;
  Index v_max_abs_index = -1;
  Index old_v_max_abs_index = v_max_abs_index;
  for (int k = 0; k < 4; ++k)
  {
    sign_vector = internal::rcond_compute_sign<Vector, RealVector, is_complex>::run(v);
    if (k > 0 && !is_complex && sign_vector == old_sign_vector) {
      // Break if the solution stagnated.
      break;
    }
    // v_max_abs_index = argmax |real( inv(matrix)^T * sign_vector )|
    v = dec.adjoint().solve(sign_vector);
    v.real().cwiseAbs().maxCoeff(&v_max_abs_index);
    if (v_max_abs_index == old_v_max_abs_index) {
      // Break if the solution stagnated.
      break;
    }
    // Move to the new simplex e_j, where j = v_max_abs_index.
    v = dec.solve(Vector::Unit(n, v_max_abs_index));  // v = inv(matrix) * e_j.
    lower_bound = v.template lpNorm<1>();
    if (lower_bound <= old_lower_bound) {
      // Break if the gradient step did not increase the lower_bound.
      break;
    }
    if (!is_complex) {
      old_sign_vector = sign_vector;
    }
    old_v_max_abs_index = v_max_abs_index;
    old_lower_bound = lower_bound;
  }
  // The following calculates an independent estimate of ||matrix||_1 by
  // multiplying matrix by a vector with entries of slowly increasing
  // magnitude and alternating sign:
  //   v_i = (-1)^{i} (1 + (i / (dim-1))), i = 0,...,dim-1.
  // This improvement to Hager's algorithm above is due to Higham. It was
  // added to make the algorithm more robust in certain corner cases where
  // large elements in the matrix might otherwise escape detection due to
  // exact cancellation (especially when op and op_adjoint correspond to a
  // sequence of backsubstitutions and permutations), which could cause
  // Hager's algorithm to vastly underestimate ||matrix||_1.
  Scalar alternating_sign(RealScalar(1));
  for (Index i = 0; i < n; ++i) {
    // The static_cast is needed when Scalar is a complex and RealScalar implements expression templates
    v[i] = alternating_sign * static_cast<RealScalar>(RealScalar(1) + (RealScalar(i) / (RealScalar(n - 1))));
    alternating_sign = -alternating_sign;
  }
  v = dec.solve(v);
  const RealScalar alternate_lower_bound = (2 * v.template lpNorm<1>()) / (3 * RealScalar(n));
  return numext::maxi(lower_bound, alternate_lower_bound);
}

References eigen_assert, Eigen::numext::maxi(), and Eigen::internal::rcond_compute_sign< Vector, RealVector, IsComplex >::run().

Referenced by rcond_estimate_helper().

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

{
  using std::sqrt;
  using std::abs;
  Matrix<RealScalar,2,2> m;
  m << numext::real(matrix.coeff(p,p)), numext::real(matrix.coeff(p,q)),
       numext::real(matrix.coeff(q,p)), numext::real(matrix.coeff(q,q));
  JacobiRotation<RealScalar> rot1;
  RealScalar t = m.coeff(0,0) + m.coeff(1,1);
  RealScalar d = m.coeff(1,0) - m.coeff(0,1);
 
  if(abs(d) < (std::numeric_limits<RealScalar>::min)())
  {
    rot1.s() = RealScalar(0);
    rot1.c() = RealScalar(1);
  }
  else
  {
    // If d!=0, then t/d cannot overflow because the magnitude of the
    // entries forming d are not too small compared to the ones forming t.
    RealScalar u = t / d;
    RealScalar tmp = sqrt(RealScalar(1) + numext::abs2(u));
    rot1.s() = RealScalar(1) / tmp;
    rot1.c() = u / tmp;
  }
  m.applyOnTheLeft(0,1,rot1);
  j_right->makeJacobi(m,0,1);
  *j_left = rot1 * j_right->transpose();
}

References Eigen::JacobiRotation< Scalar >::c(), Eigen::PlainObjectBase< Derived >::coeff(), Eigen::JacobiRotation< Scalar >::makeJacobi(), Eigen::JacobiRotation< Scalar >::s(), sqrt(), and Eigen::JacobiRotation< Scalar >::transpose().

Referenced by Eigen::RealQZ< _MatrixType >::compute(), and Eigen::JacobiSVD< _MatrixType, QRPreconditioner >::compute().

Here is the call graph for this function:

Here is the caller graph for this function:

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 &
	)

{
  EIGEN_ONLY_USED_FOR_DEBUG(dst);
  EIGEN_ONLY_USED_FOR_DEBUG(src);
  eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
}

References eigen_assert, and EIGEN_ONLY_USED_FOR_DEBUG.

Referenced by call_dense_assignment_loop(), and Eigen::internal::Assignment< DstXprType, SrcXprType, Functor, Sparse2Dense >::run().

Here is the caller graph for this function:

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 > &
	)

{
  Index dstRows = src.rows();
  Index dstCols = src.cols();
  if(((dst.rows()!=dstRows) || (dst.cols()!=dstCols)))
    dst.resize(dstRows, dstCols);
  eigen_assert(dst.rows() == dstRows && dst.cols() == dstCols);
}

References eigen_assert.

return_ptr()

template<typename T >

const T * Eigen::internal::return_ptr

(

)

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
	)

{
  enum { IsRowMajor = SparseMatrixType::IsRowMajor };
  typedef typename SparseMatrixType::Scalar Scalar;
  typedef typename SparseMatrixType::StorageIndex StorageIndex;
  SparseMatrix<Scalar,IsRowMajor?ColMajor:RowMajor,StorageIndex> trMat(mat.rows(),mat.cols());
 
  if(begin!=end)
  {
    // pass 1: count the nnz per inner-vector
    typename SparseMatrixType::IndexVector wi(trMat.outerSize());
    wi.setZero();
    for(InputIterator it(begin); it!=end; ++it)
    {
      eigen_assert(it->row()>=0 && it->row()<mat.rows() && it->col()>=0 && it->col()<mat.cols());
      wi(IsRowMajor ? it->col() : it->row())++;
    }
 
    // pass 2: insert all the elements into trMat
    trMat.reserve(wi);
    for(InputIterator it(begin); it!=end; ++it)
      trMat.insertBackUncompressed(it->row(),it->col()) = it->value();
 
    // pass 3:
    trMat.collapseDuplicates(dup_func);
  }
 
  // pass 4: transposed copy -> implicit sorting
  mat = trMat;
}

References Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::collapseDuplicates(), eigen_assert, Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::insertBackUncompressed(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::outerSize(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::reserve(), and set_from_triplets().

Referenced by set_from_triplets().

Here is the call graph for this function:

Here is the caller graph for this function:

smart_copy()

template<typename T >

EIGEN_DEVICE_FUNC void Eigen::internal::smart_copy	(	const T *	start,
		const T *	end,
		T *	target
	)

{
  smart_copy_helper<T,!NumTraits<T>::RequireInitialization>::run(start, end, target);
}

References Eigen::end().

Referenced by Eigen::DenseStorage< T, Dynamic, Dynamic, Dynamic, _Options >::DenseStorage(), Eigen::DenseStorage< T, Dynamic, _Rows, Dynamic, _Options >::DenseStorage(), Eigen::DenseStorage< T, Dynamic, Dynamic, _Cols, _Options >::DenseStorage(), Eigen::internal::CompressedStorage< _Scalar, _StorageIndex >::atWithInsertion(), Eigen::internal::CompressedStorage< _Scalar, _StorageIndex >::operator=(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::operator=(), Eigen::internal::sparse_matrix_block_impl< SparseMatrixType, BlockRows, BlockCols >::operator=(), and Eigen::internal::CompressedStorage< _Scalar, _StorageIndex >::reallocate().

Here is the call graph for this function:

Here is the caller graph for this function:

smart_memmove()

template<typename T >

void Eigen::internal::smart_memmove	(	const T *	start,
		const T *	end,
		T *	target
	)

{
  smart_memmove_helper<T,!NumTraits<T>::RequireInitialization>::run(start, end, target);
}

References Eigen::end().

Referenced by Eigen::internal::CompressedStorage< _Scalar, _StorageIndex >::atWithInsertion(), and Eigen::internal::sparse_matrix_block_impl< SparseMatrixType, BlockRows, BlockCols >::operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

{
  EIGEN_STATIC_ASSERT((Dest::Flags&RowMajorBit)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
  typedef typename Dest::Scalar DestScalar;
  // we process the sparse rhs per block of NbColsAtOnce columns temporarily stored into a dense matrix.
  static const Index NbColsAtOnce = 4;
  Index rhsCols = rhs.cols();
  Index size = rhs.rows();
  // the temporary matrices do not need more columns than NbColsAtOnce:
  Index tmpCols = (std::min)(rhsCols, NbColsAtOnce); 
  Eigen::Matrix<DestScalar,Dynamic,Dynamic> tmp(size,tmpCols);
  Eigen::Matrix<DestScalar,Dynamic,Dynamic> tmpX(size,tmpCols);
  for(Index k=0; k<rhsCols; k+=NbColsAtOnce)
  {
    Index actualCols = std::min<Index>(rhsCols-k, NbColsAtOnce);
    tmp.leftCols(actualCols) = rhs.middleCols(k,actualCols);
    tmpX.leftCols(actualCols) = dec.solve(tmp.leftCols(actualCols));
    dest.middleCols(k,actualCols) = tmpX.leftCols(actualCols).sparseView();
  }
}

References EIGEN_STATIC_ASSERT, and Eigen::RowMajorBit.

Referenced by Eigen::SimplicialCholeskyBase< Derived >::_solve_impl(), Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::_solve_impl(), and Eigen::SparseSolverBase< Derived >::_solve_impl().

Here is the caller graph for this function:

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
	)

{
  typedef typename Dest::Scalar DestScalar;
  Index size = rhs.rows();
  Eigen::Matrix<DestScalar,Dynamic,1> rhs_dense(rhs);
  Eigen::Matrix<DestScalar,Dynamic,1> dest_dense(size);
  dest_dense = dec.solve(rhs_dense);
  dest = dest_dense.sparseView();
}

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

{
  EIGEN_ONLY_USED_FOR_DEBUG(alpha);
  
  typedef typename internal::nested_eval<SparseLhsType,DenseRhsType::MaxColsAtCompileTime>::type SparseLhsTypeNested;
  typedef typename internal::remove_all<SparseLhsTypeNested>::type SparseLhsTypeNestedCleaned;
  typedef evaluator<SparseLhsTypeNestedCleaned> LhsEval;
  typedef typename LhsEval::InnerIterator LhsIterator;
  typedef typename SparseLhsType::Scalar LhsScalar;
  
  enum {
    LhsIsRowMajor = (LhsEval::Flags&RowMajorBit)==RowMajorBit,
    ProcessFirstHalf =
              ((Mode&(Upper|Lower))==(Upper|Lower))
          || ( (Mode&Upper) && !LhsIsRowMajor)
          || ( (Mode&Lower) && LhsIsRowMajor),
    ProcessSecondHalf = !ProcessFirstHalf
  };
  
  SparseLhsTypeNested lhs_nested(lhs);
  LhsEval lhsEval(lhs_nested);
 
  // work on one column at once
  for (Index k=0; k<rhs.cols(); ++k)
  {
    for (Index j=0; j<lhs.outerSize(); ++j)
    {
      LhsIterator i(lhsEval,j);
      // handle diagonal coeff
      if (ProcessSecondHalf)
      {
        while (i && i.index()<j) ++i;
        if(i && i.index()==j)
        {
          res.coeffRef(j,k) += alpha * i.value() * rhs.coeff(j,k);
          ++i;
        }
      }
 
      // premultiplied rhs for scatters
      typename ScalarBinaryOpTraits<AlphaType, typename DenseRhsType::Scalar>::ReturnType rhs_j(alpha*rhs(j,k));
      // accumulator for partial scalar product
      typename DenseResType::Scalar res_j(0);
      for(; (ProcessFirstHalf ? i && i.index() < j : i) ; ++i)
      {
        LhsScalar lhs_ij = i.value();
        if(!LhsIsRowMajor) lhs_ij = numext::conj(lhs_ij);
        res_j += lhs_ij * rhs.coeff(i.index(),k);
        res(i.index(),k) += numext::conj(lhs_ij) * rhs_j;
      }
      res.coeffRef(j,k) += alpha * res_j;
 
      // handle diagonal coeff
      if (ProcessFirstHalf && i && (i.index()==j))
        res.coeffRef(j,k) += alpha * i.value() * rhs.coeff(j,k);
    }
  }
}

References EIGEN_ONLY_USED_FOR_DEBUG, Eigen::Lower, Eigen::RowMajorBit, sparse_selfadjoint_time_dense_product(), and Eigen::Upper.

Referenced by sparse_selfadjoint_time_dense_product().

Here is the call graph for this function:

Here is the caller graph for this function:

sparse_sparse_product_with_pruning_impl()

template<typename Lhs , typename Rhs , typename ResultType >

static void Eigen::internal::sparse_sparse_product_with_pruning_impl ( const Lhs &  lhs, const Rhs &  rhs, ResultType &  res, const typename ResultType::RealScalar &  tolerance  )

static

{
  // return sparse_sparse_product_with_pruning_impl2(lhs,rhs,res);
 
  typedef typename remove_all<Rhs>::type::Scalar RhsScalar;
  typedef typename remove_all<ResultType>::type::Scalar ResScalar;
  typedef typename remove_all<Lhs>::type::StorageIndex StorageIndex;
 
  // make sure to call innerSize/outerSize since we fake the storage order.
  Index rows = lhs.innerSize();
  Index cols = rhs.outerSize();
  //Index size = lhs.outerSize();
  eigen_assert(lhs.outerSize() == rhs.innerSize());
 
  // allocate a temporary buffer
  AmbiVector<ResScalar,StorageIndex> tempVector(rows);
 
  // mimics a resizeByInnerOuter:
  if(ResultType::IsRowMajor)
    res.resize(cols, rows);
  else
    res.resize(rows, cols);
  
  evaluator<Lhs> lhsEval(lhs);
  evaluator<Rhs> rhsEval(rhs);
  
  // estimate the number of non zero entries
  // given a rhs column containing Y non zeros, we assume that the respective Y columns
  // of the lhs differs in average of one non zeros, thus the number of non zeros for
  // the product of a rhs column with the lhs is X+Y where X is the average number of non zero
  // per column of the lhs.
  // Therefore, we have nnz(lhs*rhs) = nnz(lhs) + nnz(rhs)
  Index estimated_nnz_prod = lhsEval.nonZerosEstimate() + rhsEval.nonZerosEstimate();
 
  res.reserve(estimated_nnz_prod);
  double ratioColRes = double(estimated_nnz_prod)/(double(lhs.rows())*double(rhs.cols()));
  for (Index j=0; j<cols; ++j)
  {
    // FIXME:
    //double ratioColRes = (double(rhs.innerVector(j).nonZeros()) + double(lhs.nonZeros())/double(lhs.cols()))/double(lhs.rows());
    // let's do a more accurate determination of the nnz ratio for the current column j of res
    tempVector.init(ratioColRes);
    tempVector.setZero();
    for (typename evaluator<Rhs>::InnerIterator rhsIt(rhsEval, j); rhsIt; ++rhsIt)
    {
      // FIXME should be written like this: tmp += rhsIt.value() * lhs.col(rhsIt.index())
      tempVector.restart();
      RhsScalar x = rhsIt.value();
      for (typename evaluator<Lhs>::InnerIterator lhsIt(lhsEval, rhsIt.index()); lhsIt; ++lhsIt)
      {
        tempVector.coeffRef(lhsIt.index()) += lhsIt.value() * x;
      }
    }
    res.startVec(j);
    for (typename AmbiVector<ResScalar,StorageIndex>::Iterator it(tempVector,tolerance); it; ++it)
      res.insertBackByOuterInner(j,it.index()) = it.value();
  }
  res.finalize();
}

References Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::coeffRef(), eigen_assert, Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::init(), Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::restart(), and Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::setZero().

Here is the call graph for this function:

sparse_sparse_to_dense_product_impl()

template<typename Lhs , typename Rhs , typename ResultType >

static void Eigen::internal::sparse_sparse_to_dense_product_impl ( const Lhs &  lhs, const Rhs &  rhs, ResultType &  res  )

static

{
  typedef typename remove_all<Lhs>::type::Scalar LhsScalar;
  typedef typename remove_all<Rhs>::type::Scalar RhsScalar;
  Index cols = rhs.outerSize();
  eigen_assert(lhs.outerSize() == rhs.innerSize());
 
  evaluator<Lhs> lhsEval(lhs);
  evaluator<Rhs> rhsEval(rhs);
 
  for (Index j=0; j<cols; ++j)
  {
    for (typename evaluator<Rhs>::InnerIterator rhsIt(rhsEval, j); rhsIt; ++rhsIt)
    {
      RhsScalar y = rhsIt.value();
      Index k = rhsIt.index();
      for (typename evaluator<Lhs>::InnerIterator lhsIt(lhsEval, k); lhsIt; ++lhsIt)
      {
        Index i = lhsIt.index();
        LhsScalar x = lhsIt.value();
        res.coeffRef(i,j) += x * y;
      }
    }
  }
}

References eigen_assert, and y.

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

{
  sparse_time_dense_product_impl<SparseLhsType,DenseRhsType,DenseResType, AlphaType>::run(lhs, rhs, res, alpha);
}

Referenced by Eigen::BlockSparseTimeDenseProduct< Lhs, Rhs >::scaleAndAddTo(), Eigen::internal::generic_product_impl< Lhs, Rhs, SparseShape, DenseShape, ProductType >::scaleAndAddTo(), and Eigen::internal::generic_product_impl< Lhs, Rhs, DenseShape, SparseShape, ProductType >::scaleAndAddTo().

Here is the caller graph for this function:

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
	)

{
  using namespace Eigen::internal;
  
  typedef typename packet_traits<Scalar>::type Packet;
  enum {
    NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS,
    PacketSize = packet_traits<Scalar>::size,
    PM = 8,                             // peeling in M
    RN = 2,                             // register blocking
    RK = NumberOfRegisters>=16 ? 4 : 2, // register blocking
    BM = 4096/sizeof(Scalar),           // number of rows of A-C per chunk
    SM = PM*PacketSize                  // step along M
  };
  Index d_end = (d/RK)*RK;    // number of columns of A (rows of B) suitable for full register blocking
  Index n_end = (n/RN)*RN;    // number of columns of B-C suitable for processing RN columns at once
  Index i0 = internal::first_default_aligned(A,m);
  
  eigen_internal_assert(((lda%PacketSize)==0) && ((ldc%PacketSize)==0) && (i0==internal::first_default_aligned(C,m)));
  
  // handle the non aligned rows of A and C without any optimization:
  for(Index i=0; i<i0; ++i)
  {
    for(Index j=0; j<n; ++j)
    {
      Scalar c = C[i+j*ldc];
      for(Index k=0; k<d; ++k)
        c += B[k+j*ldb] * A[i+k*lda];
      C[i+j*ldc] = c;
    }
  }
  // process the remaining rows per chunk of BM rows
  for(Index ib=i0; ib<m; ib+=BM)
  {
    Index actual_b = std::min<Index>(BM, m-ib);                 // actual number of rows
    Index actual_b_end1 = (actual_b/SM)*SM;                   // actual number of rows suitable for peeling
    Index actual_b_end2 = (actual_b/PacketSize)*PacketSize;   // actual number of rows suitable for vectorization
    
    // Let's process two columns of B-C at once
    for(Index j=0; j<n_end; j+=RN)
    {
      const Scalar* Bc0 = B+(j+0)*ldb;
      const Scalar* Bc1 = B+(j+1)*ldb;
      
      for(Index k=0; k<d_end; k+=RK)
      {
        
        // load and expand a RN x RK block of B
        Packet b00, b10, b20, b30, b01, b11, b21, b31;
                  { b00 = pset1<Packet>(Bc0[0]); }
                  { b10 = pset1<Packet>(Bc0[1]); }
        if(RK==4) { b20 = pset1<Packet>(Bc0[2]); }
        if(RK==4) { b30 = pset1<Packet>(Bc0[3]); }
                  { b01 = pset1<Packet>(Bc1[0]); }
                  { b11 = pset1<Packet>(Bc1[1]); }
        if(RK==4) { b21 = pset1<Packet>(Bc1[2]); }
        if(RK==4) { b31 = pset1<Packet>(Bc1[3]); }
        
        Packet a0, a1, a2, a3, c0, c1, t0, t1;
        
        const Scalar* A0 = A+ib+(k+0)*lda;
        const Scalar* A1 = A+ib+(k+1)*lda;
        const Scalar* A2 = A+ib+(k+2)*lda;
        const Scalar* A3 = A+ib+(k+3)*lda;
        
        Scalar* C0 = C+ib+(j+0)*ldc;
        Scalar* C1 = C+ib+(j+1)*ldc;
        
                  a0 = pload<Packet>(A0);
                  a1 = pload<Packet>(A1);
        if(RK==4)
        {
          a2 = pload<Packet>(A2);
          a3 = pload<Packet>(A3);
        }
        else
        {
          // workaround "may be used uninitialized in this function" warning
          a2 = a3 = a0;
        }
        
#define KMADD(c, a, b, tmp) {tmp = b; tmp = pmul(a,tmp); c = padd(c,tmp);}
#define WORK(I)  \
                     c0 = pload<Packet>(C0+i+(I)*PacketSize);    \
                     c1 = pload<Packet>(C1+i+(I)*PacketSize);    \
                     KMADD(c0, a0, b00, t0)                      \
                     KMADD(c1, a0, b01, t1)                      \
                     a0 = pload<Packet>(A0+i+(I+1)*PacketSize);  \
                     KMADD(c0, a1, b10, t0)                      \
                     KMADD(c1, a1, b11, t1)                      \
                     a1 = pload<Packet>(A1+i+(I+1)*PacketSize);  \
          if(RK==4){ KMADD(c0, a2, b20, t0)                     }\
          if(RK==4){ KMADD(c1, a2, b21, t1)                     }\
          if(RK==4){ a2 = pload<Packet>(A2+i+(I+1)*PacketSize); }\
          if(RK==4){ KMADD(c0, a3, b30, t0)                     }\
          if(RK==4){ KMADD(c1, a3, b31, t1)                     }\
          if(RK==4){ a3 = pload<Packet>(A3+i+(I+1)*PacketSize); }\
                     pstore(C0+i+(I)*PacketSize, c0);            \
                     pstore(C1+i+(I)*PacketSize, c1)
        
        // process rows of A' - C' with aggressive vectorization and peeling 
        for(Index i=0; i<actual_b_end1; i+=PacketSize*8)
        {
          EIGEN_ASM_COMMENT("SPARSELU_GEMML_KERNEL1");
                    prefetch((A0+i+(5)*PacketSize));
                    prefetch((A1+i+(5)*PacketSize));
          if(RK==4) prefetch((A2+i+(5)*PacketSize));
          if(RK==4) prefetch((A3+i+(5)*PacketSize));
 
          WORK(0);
          WORK(1);
          WORK(2);
          WORK(3);
          WORK(4);
          WORK(5);
          WORK(6);
          WORK(7);
        }
        // process the remaining rows with vectorization only
        for(Index i=actual_b_end1; i<actual_b_end2; i+=PacketSize)
        {
          WORK(0);
        }
#undef WORK
        // process the remaining rows without vectorization
        for(Index i=actual_b_end2; i<actual_b; ++i)
        {
          if(RK==4)
          {
            C0[i] += A0[i]*Bc0[0]+A1[i]*Bc0[1]+A2[i]*Bc0[2]+A3[i]*Bc0[3];
            C1[i] += A0[i]*Bc1[0]+A1[i]*Bc1[1]+A2[i]*Bc1[2]+A3[i]*Bc1[3];
          }
          else
          {
            C0[i] += A0[i]*Bc0[0]+A1[i]*Bc0[1];
            C1[i] += A0[i]*Bc1[0]+A1[i]*Bc1[1];
          }
        }
        
        Bc0 += RK;
        Bc1 += RK;
      } // peeled loop on k
    } // peeled loop on the columns j
    // process the last column (we now perform a matrix-vector product)
    if((n-n_end)>0)
    {
      const Scalar* Bc0 = B+(n-1)*ldb;
      
      for(Index k=0; k<d_end; k+=RK)
      {
        
        // load and expand a 1 x RK block of B
        Packet b00, b10, b20, b30;
                  b00 = pset1<Packet>(Bc0[0]);
                  b10 = pset1<Packet>(Bc0[1]);
        if(RK==4) b20 = pset1<Packet>(Bc0[2]);
        if(RK==4) b30 = pset1<Packet>(Bc0[3]);
        
        Packet a0, a1, a2, a3, c0, t0/*, t1*/;
        
        const Scalar* A0 = A+ib+(k+0)*lda;
        const Scalar* A1 = A+ib+(k+1)*lda;
        const Scalar* A2 = A+ib+(k+2)*lda;
        const Scalar* A3 = A+ib+(k+3)*lda;
        
        Scalar* C0 = C+ib+(n_end)*ldc;
        
                  a0 = pload<Packet>(A0);
                  a1 = pload<Packet>(A1);
        if(RK==4)
        {
          a2 = pload<Packet>(A2);
          a3 = pload<Packet>(A3);
        }
        else
        {
          // workaround "may be used uninitialized in this function" warning
          a2 = a3 = a0;
        }
        
#define WORK(I) \
                   c0 = pload<Packet>(C0+i+(I)*PacketSize);     \
                   KMADD(c0, a0, b00, t0)                       \
                   a0 = pload<Packet>(A0+i+(I+1)*PacketSize);   \
                   KMADD(c0, a1, b10, t0)                       \
                   a1 = pload<Packet>(A1+i+(I+1)*PacketSize);   \
        if(RK==4){ KMADD(c0, a2, b20, t0)                      }\
        if(RK==4){ a2 = pload<Packet>(A2+i+(I+1)*PacketSize);  }\
        if(RK==4){ KMADD(c0, a3, b30, t0)                      }\
        if(RK==4){ a3 = pload<Packet>(A3+i+(I+1)*PacketSize);  }\
                   pstore(C0+i+(I)*PacketSize, c0);
        
        // agressive vectorization and peeling
        for(Index i=0; i<actual_b_end1; i+=PacketSize*8)
        {
          EIGEN_ASM_COMMENT("SPARSELU_GEMML_KERNEL2");
          WORK(0);
          WORK(1);
          WORK(2);
          WORK(3);
          WORK(4);
          WORK(5);
          WORK(6);
          WORK(7);
        }
        // vectorization only
        for(Index i=actual_b_end1; i<actual_b_end2; i+=PacketSize)
        {
          WORK(0);
        }
        // remaining scalars
        for(Index i=actual_b_end2; i<actual_b; ++i)
        {
          if(RK==4) 
            C0[i] += A0[i]*Bc0[0]+A1[i]*Bc0[1]+A2[i]*Bc0[2]+A3[i]*Bc0[3];
          else
            C0[i] += A0[i]*Bc0[0]+A1[i]*Bc0[1];
        }
        
        Bc0 += RK;
#undef WORK
      }
    }
    
    // process the last columns of A, corresponding to the last rows of B
    Index rd = d-d_end;
    if(rd>0)
    {
      for(Index j=0; j<n; ++j)
      {
        enum {
          Alignment = PacketSize>1 ? Aligned : 0
        };
        typedef Map<Matrix<Scalar,Dynamic,1>, Alignment > MapVector;
        typedef Map<const Matrix<Scalar,Dynamic,1>, Alignment > ConstMapVector;
        if(rd==1)       MapVector(C+j*ldc+ib,actual_b) += B[0+d_end+j*ldb] * ConstMapVector(A+(d_end+0)*lda+ib, actual_b);
        
        else if(rd==2)  MapVector(C+j*ldc+ib,actual_b) += B[0+d_end+j*ldb] * ConstMapVector(A+(d_end+0)*lda+ib, actual_b)
                                                        + B[1+d_end+j*ldb] * ConstMapVector(A+(d_end+1)*lda+ib, actual_b);
        
        else            MapVector(C+j*ldc+ib,actual_b) += B[0+d_end+j*ldb] * ConstMapVector(A+(d_end+0)*lda+ib, actual_b)
                                                        + B[1+d_end+j*ldb] * ConstMapVector(A+(d_end+1)*lda+ib, actual_b)
                                                        + B[2+d_end+j*ldb] * ConstMapVector(A+(d_end+2)*lda+ib, actual_b);
      }
    }
  
  } // blocking on the rows of A and C
}

References Eigen::Aligned, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS, EIGEN_ASM_COMMENT, eigen_internal_assert, first_default_aligned(), prefetch(), and WORK.

Here is the call graph for this function:

stable_norm_kernel()

template<typename ExpressionType , typename Scalar >

void Eigen::internal::stable_norm_kernel ( const ExpressionType &  bl, Scalar &  ssq, Scalar &  scale, Scalar &  invScale  )

inline

{
  Scalar maxCoeff = bl.cwiseAbs().maxCoeff();
  
  if(maxCoeff>scale)
  {
    ssq = ssq * numext::abs2(scale/maxCoeff);
    Scalar tmp = Scalar(1)/maxCoeff;
    if(tmp > NumTraits<Scalar>::highest())
    {
      invScale = NumTraits<Scalar>::highest();
      scale = Scalar(1)/invScale;
    }
    else if(maxCoeff>NumTraits<Scalar>::highest()) // we got a INF
    {
      invScale = Scalar(1);
      scale = maxCoeff;
    }
    else
    {
      scale = maxCoeff;
      invScale = tmp;
    }
  }
  else if(maxCoeff!=maxCoeff) // we got a NaN
  {
    scale = maxCoeff;
  }
  
  // TODO if the maxCoeff is much much smaller than the current scale,
  // then we can neglect this sub vector
  if(scale>Scalar(0)) // if scale==0, then bl is 0 
    ssq += (bl*invScale).squaredNorm();
}

References scale().

Referenced by Eigen::MatrixBase< Derived >::stableNorm().

Here is the call graph for this function:

Here is the caller graph for this function:

swap()

template<typename T >

void Eigen::internal::swap	(	scoped_array< T > &	a,
		scoped_array< T > &	b
	)

{
  std::swap(a.ptr(),b.ptr());
}

Referenced by Eigen::internal::swap_assign_op< Scalar >::assignCoeff(), and QuickSplit().

Here is the caller graph for this function:

throw_std_bad_alloc()

EIGEN_DEVICE_FUNC void Eigen::internal::throw_std_bad_alloc ( )

inline

{
  #ifdef EIGEN_EXCEPTIONS
    throw std::bad_alloc();
  #else
    std::size_t huge = static_cast<std::size_t>(-1);
    ::operator new(huge);
  #endif
}

Referenced by aligned_malloc(), aligned_realloc(), check_size_for_overflow(), conditional_aligned_malloc< false >(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::conservativeResize(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::reserveInnerVectors(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::resize(), Eigen::internal::CompressedStorage< _Scalar, _StorageIndex >::resize(), and Eigen::internal::check_rows_cols_for_overflow< Dynamic >::run().

Here is the caller graph for this function:

toRotationMatrix() [1/3]

template<typename Scalar , int Dim, typename OtherDerived >

static EIGEN_DEVICE_FUNC const MatrixBase< OtherDerived > & Eigen::internal::toRotationMatrix ( const MatrixBase< OtherDerived > &  mat )

inlinestatic

{
  EIGEN_STATIC_ASSERT(OtherDerived::RowsAtCompileTime==Dim && OtherDerived::ColsAtCompileTime==Dim,
    YOU_MADE_A_PROGRAMMING_MISTAKE)
  return mat;
}

References EIGEN_STATIC_ASSERT.

toRotationMatrix() [2/3]

template<typename Scalar , int Dim, typename OtherDerived >

static EIGEN_DEVICE_FUNC Matrix< Scalar, Dim, Dim > Eigen::internal::toRotationMatrix ( const RotationBase< OtherDerived, Dim > &  r )

inlinestatic

{
  return r.toRotationMatrix();
}

References Eigen::RotationBase< Derived, _Dim >::toRotationMatrix().

Here is the call graph for this function:

toRotationMatrix() [3/3]

template<typename Scalar , int Dim>

static EIGEN_DEVICE_FUNC Matrix< Scalar, 2, 2 > Eigen::internal::toRotationMatrix ( const Scalar &  s )

inlinestatic

{
  EIGEN_STATIC_ASSERT(Dim==2,YOU_MADE_A_PROGRAMMING_MISTAKE)
  return Rotation2D<Scalar>(s).toRotationMatrix();
}

References EIGEN_STATIC_ASSERT, and Eigen::Rotation2D< _Scalar >::toRotationMatrix().

Here is the call graph for this function:

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

{
  typedef typename IndexVector::Scalar StorageIndex;
  IndexVector first_kid, next_kid; // Linked list of children 
  StorageIndex postnum; 
  // Allocate storage for working arrays and results 
  first_kid.resize(n+1); 
  next_kid.setZero(n+1);
  post.setZero(n+1);
  
  // Set up structure describing children
  first_kid.setConstant(-1); 
  for (StorageIndex v = n-1; v >= 0; v--) 
  {
    StorageIndex dad = parent(v);
    next_kid(v) = first_kid(dad); 
    first_kid(dad) = v; 
  }
  
  // Depth-first search from dummy root vertex #n
  postnum = 0; 
  internal::nr_etdfs(n, parent, first_kid, next_kid, post, postnum);
}

References nr_etdfs().

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::analyzePattern(), and Eigen::internal::SparseLUImpl< Scalar, StorageIndex >::heap_relax_snode().

Here is the call graph for this function:

Here is the caller graph for this function:

tridiagonal_qr_step()

template<int StorageOrder, typename RealScalar , typename Scalar , typename Index >

static EIGEN_DEVICE_FUNC void Eigen::internal::tridiagonal_qr_step ( RealScalar *  diag, RealScalar *  subdiag, Index  start, Index  end, Scalar *  matrixQ, Index  n  )

static

{
  using std::abs;
  RealScalar td = (diag[end-1] - diag[end])*RealScalar(0.5);
  RealScalar e = subdiag[end-1];
  // Note that thanks to scaling, e^2 or td^2 cannot overflow, however they can still
  // underflow thus leading to inf/NaN values when using the following commented code:
//   RealScalar e2 = numext::abs2(subdiag[end-1]);
//   RealScalar mu = diag[end] - e2 / (td + (td>0 ? 1 : -1) * sqrt(td*td + e2));
  // This explain the following, somewhat more complicated, version:
  RealScalar mu = diag[end];
  if(td==RealScalar(0))
    mu -= abs(e);
  else
  {
    RealScalar e2 = numext::abs2(subdiag[end-1]);
    RealScalar h = numext::hypot(td,e);
    if(e2==RealScalar(0)) mu -= (e / (td + (td>RealScalar(0) ? RealScalar(1) : RealScalar(-1)))) * (e / h);
    else                  mu -= e2 / (td + (td>RealScalar(0) ? h : -h));
  }
  
  RealScalar x = diag[start] - mu;
  RealScalar z = subdiag[start];
  for (Index k = start; k < end; ++k)
  {
    JacobiRotation<RealScalar> rot;
    rot.makeGivens(x, z);
 
    // do T = G' T G
    RealScalar sdk = rot.s() * diag[k] + rot.c() * subdiag[k];
    RealScalar dkp1 = rot.s() * subdiag[k] + rot.c() * diag[k+1];
 
    diag[k] = rot.c() * (rot.c() * diag[k] - rot.s() * subdiag[k]) - rot.s() * (rot.c() * subdiag[k] - rot.s() * diag[k+1]);
    diag[k+1] = rot.s() * sdk + rot.c() * dkp1;
    subdiag[k] = rot.c() * sdk - rot.s() * dkp1;
    
 
    if (k > start)
      subdiag[k - 1] = rot.c() * subdiag[k-1] - rot.s() * z;
 
    x = subdiag[k];
 
    if (k < end - 1)
    {
      z = -rot.s() * subdiag[k+1];
      subdiag[k + 1] = rot.c() * subdiag[k+1];
    }
    
    // apply the givens rotation to the unit matrix Q = Q * G
    if (matrixQ)
    {
      // FIXME if StorageOrder == RowMajor this operation is not very efficient
      Map<Matrix<Scalar,Dynamic,Dynamic,StorageOrder> > q(matrixQ,n,n);
      q.applyOnTheRight(k,k+1,rot);
    }
  }
}

References Eigen::JacobiRotation< Scalar >::c(), Eigen::end(), Eigen::JacobiRotation< Scalar >::makeGivens(), and Eigen::JacobiRotation< Scalar >::s().

Here is the call graph for this function:

tridiagonalization_inplace() [1/2]

template<typename MatrixType , typename DiagonalType , typename SubDiagonalType >

void Eigen::internal::tridiagonalization_inplace	(	MatrixType &	mat,
		DiagonalType &	diag,
		SubDiagonalType &	subdiag,
		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

{
  eigen_assert(mat.cols()==mat.rows() && diag.size()==mat.rows() && subdiag.size()==mat.rows()-1);
  tridiagonalization_inplace_selector<MatrixType>::run(mat, diag, subdiag, extractQ);
}

References eigen_assert, and tridiagonalization_inplace().

Here is the call graph for this function:

tridiagonalization_inplace() [2/2]

template<typename MatrixType , typename CoeffVectorType >

void Eigen::internal::tridiagonalization_inplace	(	MatrixType &	matA,
		CoeffVectorType &	hCoeffs
	)

{
  using numext::conj;
  typedef typename MatrixType::Scalar Scalar;
  typedef typename MatrixType::RealScalar RealScalar;
  Index n = matA.rows();
  eigen_assert(n==matA.cols());
  eigen_assert(n==hCoeffs.size()+1 || n==1);
  
  for (Index i = 0; i<n-1; ++i)
  {
    Index remainingSize = n-i-1;
    RealScalar beta;
    Scalar h;
    matA.col(i).tail(remainingSize).makeHouseholderInPlace(h, beta);
 
    // Apply similarity transformation to remaining columns,
    // i.e., A = H A H' where H = I - h v v' and v = matA.col(i).tail(n-i-1)
    matA.col(i).coeffRef(i+1) = 1;
 
    hCoeffs.tail(n-i-1).noalias() = (matA.bottomRightCorner(remainingSize,remainingSize).template selfadjointView<Lower>()
                                  * (conj(h) * matA.col(i).tail(remainingSize)));
 
    hCoeffs.tail(n-i-1) += (conj(h)*RealScalar(-0.5)*(hCoeffs.tail(remainingSize).dot(matA.col(i).tail(remainingSize)))) * matA.col(i).tail(n-i-1);
 
    matA.bottomRightCorner(remainingSize, remainingSize).template selfadjointView<Lower>()
      .rankUpdate(matA.col(i).tail(remainingSize), hCoeffs.tail(remainingSize), Scalar(-1));
 
    matA.col(i).coeffRef(i+1) = beta;
    hCoeffs.coeffRef(i) = h;
  }
}

References eigen_assert, and tridiagonalization_inplace().

Referenced by Eigen::Tridiagonalization< _MatrixType >::Tridiagonalization(), Eigen::SelfAdjointEigenSolver< _MatrixType >::compute(), Eigen::Tridiagonalization< _MatrixType >::compute(), Eigen::internal::tridiagonalization_inplace_selector< MatrixType, Size, IsComplex >::run(), tridiagonalization_inplace(), and tridiagonalization_inplace().

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

{
  typedef typename MatrixType::Scalar Scalar;
  typedef typename MatrixType::RealScalar RealScalar;
  typedef typename NumTraits<RealScalar>::Literal Literal;
  enum { StorageOrder = traits<MatrixType>::Flags & RowMajorBit };
  typedef InnerStride<int(StorageOrder) == int(ColMajor) ? 1 : Dynamic> ColInnerStride;
  typedef InnerStride<int(StorageOrder) == int(ColMajor) ? Dynamic : 1> RowInnerStride;
  typedef Ref<Matrix<Scalar, Dynamic, 1>, 0, ColInnerStride>    SubColumnType;
  typedef Ref<Matrix<Scalar, 1, Dynamic>, 0, RowInnerStride>    SubRowType;
  typedef Ref<Matrix<Scalar, Dynamic, Dynamic, StorageOrder > > SubMatType;
  
  Index brows = A.rows();
  Index bcols = A.cols();
 
  Scalar tau_u, tau_u_prev(0), tau_v;
 
  for(Index k = 0; k < bs; ++k)
  {
    Index remainingRows = brows - k;
    Index remainingCols = bcols - k - 1;
 
    SubMatType X_k1( X.block(k,0, remainingRows,k) );
    SubMatType V_k1( A.block(k,0, remainingRows,k) );
 
    // 1 - update the k-th column of A
    SubColumnType v_k = A.col(k).tail(remainingRows);
          v_k -= V_k1 * Y.row(k).head(k).adjoint();
    if(k) v_k -= X_k1 * A.col(k).head(k);
    
    // 2 - construct left Householder transform in-place
    v_k.makeHouseholderInPlace(tau_v, diagonal[k]);
       
    if(k+1<bcols)
    {
      SubMatType Y_k  ( Y.block(k+1,0, remainingCols, k+1) );
      SubMatType U_k1 ( A.block(0,k+1, k,remainingCols) );
      
      // this eases the application of Householder transforAions
      // A(k,k) will store tau_v later
      A(k,k) = Scalar(1);
 
      // 3 - Compute y_k^T = tau_v * ( A^T*v_k - Y_k-1*V_k-1^T*v_k - U_k-1*X_k-1^T*v_k )
      {
        SubColumnType y_k( Y.col(k).tail(remainingCols) );
        
        // let's use the begining of column k of Y as a temporary vector
        SubColumnType tmp( Y.col(k).head(k) );
        y_k.noalias()  = A.block(k,k+1, remainingRows,remainingCols).adjoint() * v_k; // bottleneck
        tmp.noalias()  = V_k1.adjoint()  * v_k;
        y_k.noalias() -= Y_k.leftCols(k) * tmp;
        tmp.noalias()  = X_k1.adjoint()  * v_k;
        y_k.noalias() -= U_k1.adjoint()  * tmp;
        y_k *= numext::conj(tau_v);
      }
 
      // 4 - update k-th row of A (it will become u_k)
      SubRowType u_k( A.row(k).tail(remainingCols) );
      u_k = u_k.conjugate();
      {
        u_k -= Y_k * A.row(k).head(k+1).adjoint();
        if(k) u_k -= U_k1.adjoint() * X.row(k).head(k).adjoint();
      }
 
      // 5 - construct right Householder transform in-place
      u_k.makeHouseholderInPlace(tau_u, upper_diagonal[k]);
 
      // this eases the application of Householder transformations
      // A(k,k+1) will store tau_u later
      A(k,k+1) = Scalar(1);
 
      // 6 - Compute x_k = tau_u * ( A*u_k - X_k-1*U_k-1^T*u_k - V_k*Y_k^T*u_k )
      {
        SubColumnType x_k ( X.col(k).tail(remainingRows-1) );
        
        // let's use the begining of column k of X as a temporary vectors
        // note that tmp0 and tmp1 overlaps
        SubColumnType tmp0 ( X.col(k).head(k) ),
                      tmp1 ( X.col(k).head(k+1) );
                    
        x_k.noalias()   = A.block(k+1,k+1, remainingRows-1,remainingCols) * u_k.transpose(); // bottleneck
        tmp0.noalias()  = U_k1 * u_k.transpose();
        x_k.noalias()  -= X_k1.bottomRows(remainingRows-1) * tmp0;
        tmp1.noalias()  = Y_k.adjoint() * u_k.transpose();
        x_k.noalias()  -= A.block(k+1,0, remainingRows-1,k+1) * tmp1;
        x_k *= numext::conj(tau_u);
        tau_u = numext::conj(tau_u);
        u_k = u_k.conjugate();
      }
 
      if(k>0) A.coeffRef(k-1,k) = tau_u_prev;
      tau_u_prev = tau_u;
    }
    else
      A.coeffRef(k-1,k) = tau_u_prev;
 
    A.coeffRef(k,k) = tau_v;
  }
  
  if(bs<bcols)
    A.coeffRef(bs-1,bs) = tau_u_prev;
 
  // update A22
  if(bcols>bs && brows>bs)
  {
    SubMatType A11( A.bottomRightCorner(brows-bs,bcols-bs) );
    SubMatType A10( A.block(bs,0, brows-bs,bs) );
    SubMatType A01( A.block(0,bs, bs,bcols-bs) );
    Scalar tmp = A01(bs-1,0);
    A01(bs-1,0) = Literal(1);
    A11.noalias() -= A10 * Y.topLeftCorner(bcols,bs).bottomRows(bcols-bs).adjoint();
    A11.noalias() -= X.topLeftCorner(brows,bs).bottomRows(brows-bs) * A01;
    A01(bs-1,0) = tmp;
  }
}

References Eigen::ColMajor, Eigen::Dynamic, and Eigen::RowMajorBit.

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
	)

{
  typedef typename MatrixType::Scalar Scalar;
  typedef Block<MatrixType,Dynamic,Dynamic> BlockType;
 
  Index rows = A.rows();
  Index cols = A.cols();
  Index size = (std::min)(rows, cols);
 
  // X and Y are work space
  enum { StorageOrder = traits<MatrixType>::Flags & RowMajorBit };
  Matrix<Scalar,
         MatrixType::RowsAtCompileTime,
         Dynamic,
         StorageOrder,
         MatrixType::MaxRowsAtCompileTime> X(rows,maxBlockSize);
  Matrix<Scalar,
         MatrixType::ColsAtCompileTime,
         Dynamic,
         StorageOrder,
         MatrixType::MaxColsAtCompileTime> Y(cols,maxBlockSize);
  Index blockSize = (std::min)(maxBlockSize,size);
 
  Index k = 0;
  for(k = 0; k < size; k += blockSize)
  {
    Index bs = (std::min)(size-k,blockSize);  // actual size of the block
    Index brows = rows - k;                   // rows of the block
    Index bcols = cols - k;                   // columns of the block
 
    // partition the matrix A:
    // 
    //      | A00 A01 A02 |
    //      |             |
    // A  = | A10 A11 A12 |
    //      |             |
    //      | A20 A21 A22 |
    //
    // where A11 is a bs x bs diagonal block,
    // and let:
    //      | A11 A12 |
    //  B = |         |
    //      | A21 A22 |
 
    BlockType B = A.block(k,k,brows,bcols);
    
    // This stage performs the bidiagonalization of A11, A21, A12, and updating of A22.
    // Finally, the algorithm continue on the updated A22.
    //
    // However, if B is too small, or A22 empty, then let's use an unblocked strategy
    if(k+bs==cols || bcols<48) // somewhat arbitrary threshold
    {
      upperbidiagonalization_inplace_unblocked(B,
                                               &(bidiagonal.template diagonal<0>().coeffRef(k)),
                                               &(bidiagonal.template diagonal<1>().coeffRef(k)),
                                               X.data()
                                              );
      break; // We're done
    }
    else
    {
      upperbidiagonalization_blocked_helper<BlockType>( B,
                                                        &(bidiagonal.template diagonal<0>().coeffRef(k)),
                                                        &(bidiagonal.template diagonal<1>().coeffRef(k)),
                                                        bs,
                                                        X.topLeftCorner(brows,bs),
                                                        Y.topLeftCorner(bcols,bs)
                                                      );
    }
  }
}

References Eigen::Dynamic, Eigen::RowMajorBit, and upperbidiagonalization_inplace_unblocked().

Referenced by Eigen::internal::UpperBidiagonalization< _MatrixType >::compute().

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

{
  typedef typename MatrixType::Scalar Scalar;
 
  Index rows = mat.rows();
  Index cols = mat.cols();
 
  typedef Matrix<Scalar,Dynamic,1,ColMajor,MatrixType::MaxRowsAtCompileTime,1> TempType;
  TempType tempVector;
  if(tempData==0)
  {
    tempVector.resize(rows);
    tempData = tempVector.data();
  }
 
  for (Index k = 0; /* breaks at k==cols-1 below */ ; ++k)
  {
    Index remainingRows = rows - k;
    Index remainingCols = cols - k - 1;
 
    // construct left householder transform in-place in A
    mat.col(k).tail(remainingRows)
       .makeHouseholderInPlace(mat.coeffRef(k,k), diagonal[k]);
    // apply householder transform to remaining part of A on the left
    mat.bottomRightCorner(remainingRows, remainingCols)
       .applyHouseholderOnTheLeft(mat.col(k).tail(remainingRows-1), mat.coeff(k,k), tempData);
 
    if(k == cols-1) break;
 
    // construct right householder transform in-place in mat
    mat.row(k).tail(remainingCols)
       .makeHouseholderInPlace(mat.coeffRef(k,k+1), upper_diagonal[k]);
    // apply householder transform to remaining part of mat on the left
    mat.bottomRightCorner(remainingRows-1, remainingCols)
       .applyHouseholderOnTheRight(mat.row(k).tail(remainingCols-1).transpose(), mat.coeff(k,k+1), tempData);
  }
}

References Eigen::PlainObjectBase< Derived >::resize().

Referenced by Eigen::internal::UpperBidiagonalization< _MatrixType >::computeUnblocked(), and upperbidiagonalization_inplace_blocked().

Here is the call graph for this function:

Here is the caller graph for this function:

useSpecificBlockingSizes()

template<typename Index >

bool Eigen::internal::useSpecificBlockingSizes ( Index &  k, Index &  m, Index &  n  )

inline

{
#ifdef EIGEN_TEST_SPECIFIC_BLOCKING_SIZES
  if (EIGEN_TEST_SPECIFIC_BLOCKING_SIZES) {
    k = numext::mini<Index>(k, EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_K);
    m = numext::mini<Index>(m, EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_M);
    n = numext::mini<Index>(n, EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_N);
    return true;
  }
#else
  EIGEN_UNUSED_VARIABLE(k)
  EIGEN_UNUSED_VARIABLE(m)
  EIGEN_UNUSED_VARIABLE(n)
#endif
  return false;
}

References EIGEN_UNUSED_VARIABLE.

Referenced by computeProductBlockingSizes().

Here is the caller graph for this function:

vec_splat_packet4f()

template<int element>

EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec_splat_packet4f

(

const Packet4f &

from

)

{
  Packet4f splat;
  switch (element) {
  case 0:
    splat.v4f[0] = vec_splat(from.v4f[0], 0);
    splat.v4f[1] = splat.v4f[0];
    break;
  case 1:
    splat.v4f[0] = vec_splat(from.v4f[0], 1);
    splat.v4f[1] = splat.v4f[0];
    break;
  case 2:
    splat.v4f[0] = vec_splat(from.v4f[1], 0);
    splat.v4f[1] = splat.v4f[0];
    break;
  case 3:
    splat.v4f[0] = vec_splat(from.v4f[1], 1);
    splat.v4f[1] = splat.v4f[0];
    break;
  }
  return splat;
}

References Eigen::internal::Packet4f::v4f.

Variable Documentation

defaultL1CacheSize

const std::ptrdiff_t Eigen::internal::defaultL1CacheSize = 16*1024

Referenced by Eigen::internal::CacheSizes::CacheSizes(), and Eigen::internal::gebp_kernel< LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >::operator()().

defaultL2CacheSize

const std::ptrdiff_t Eigen::internal::defaultL2CacheSize = 512*1024

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

defaultL3CacheSize

const std::ptrdiff_t Eigen::internal::defaultL3CacheSize = 512*1024

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

p16uc_COMPLEX32_REV

Packet16uc Eigen::internal::p16uc_COMPLEX32_REV = vec_sld(p16uc_REVERSE32, p16uc_REVERSE32, 8)

static

Referenced by pcplxflip< Packet2cf >(), pdiv< Packet2cf >(), and pmul< Packet2cf >().

p16uc_COMPLEX32_REV2

Packet16uc Eigen::internal::p16uc_COMPLEX32_REV2 = vec_sld(p16uc_PSET64_HI, p16uc_PSET64_LO, 8)

static

Referenced by preverse().

p16uc_DUPLICATE32_HI [1/2]

Packet16uc Eigen::internal::p16uc_DUPLICATE32_HI = { 0,1,2,3, 0,1,2,3, 4,5,6,7, 4,5,6,7 }

static

Referenced by ploaddup< Packet4f >(), and ploaddup< Packet4i >().

p16uc_DUPLICATE32_HI [2/2]

Packet16uc Eigen::internal::p16uc_DUPLICATE32_HI = { 0,1,2,3, 0,1,2,3, 4,5,6,7, 4,5,6,7 }

static

p16uc_FORWARD [1/2]

Packet16uc Eigen::internal::p16uc_FORWARD = p16uc_REVERSE32

static

p16uc_FORWARD [2/2]

Packet16uc Eigen::internal::p16uc_FORWARD = { 0,1,2,3, 4,5,6,7, 8,9,10,11, 12,13,14,15 }

static

p16uc_HALF64_0_16

Packet16uc Eigen::internal::p16uc_HALF64_0_16 = vec_sld(vec_splat((Packet16uc) vec_abs(p4i_MINUS16), 0), (Packet16uc)p4i_ZERO, 8)

static

p16uc_PSET32_WEVEN [1/2]

Packet16uc Eigen::internal::p16uc_PSET32_WEVEN = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 0), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 2), 8)

static

Referenced by pmul< Packet2cf >().

p16uc_PSET32_WEVEN [2/2]

Packet16uc Eigen::internal::p16uc_PSET32_WEVEN = vec_sld(p16uc_DUPLICATE32_HI, (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 3), 8)

static

p16uc_PSET32_WODD [1/2]

Packet16uc Eigen::internal::p16uc_PSET32_WODD = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 1), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 3), 8)

static

Referenced by pmul< Packet2cf >().

p16uc_PSET32_WODD [2/2]

Packet16uc Eigen::internal::p16uc_PSET32_WODD = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 0), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 2), 8)

static

p16uc_PSET64_HI [1/2]

Packet16uc Eigen::internal::p16uc_PSET64_HI = (Packet16uc) vec_mergeh((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN)

static

Referenced by ploaddup< Packet2d >(), pmul< Packet1cd >(), and pset1< Packet2cf >().

p16uc_PSET64_HI [2/2]

Packet16uc Eigen::internal::p16uc_PSET64_HI = { 0,1,2,3, 4,5,6,7, 0,1,2,3, 4,5,6,7 }

static

p16uc_PSET64_LO [1/2]

Packet16uc Eigen::internal::p16uc_PSET64_LO = (Packet16uc) vec_mergel((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN)

static

Referenced by pmul< Packet1cd >().

p16uc_PSET64_LO [2/2]

Packet16uc Eigen::internal::p16uc_PSET64_LO = (Packet16uc) vec_mergel((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN)

static

p16uc_REVERSE32 [1/2]

Packet16uc Eigen::internal::p16uc_REVERSE32 = { 12,13,14,15, 8,9,10,11, 4,5,6,7, 0,1,2,3 }

static

Referenced by preverse(), and preverse().

p16uc_REVERSE32 [2/2]

Packet16uc Eigen::internal::p16uc_REVERSE32 = { 12,13,14,15, 8,9,10,11, 4,5,6,7, 0,1,2,3 }

static

p16uc_REVERSE64 [1/2]

Packet16uc Eigen::internal::p16uc_REVERSE64 = { 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 }

static

Referenced by pdiv< Packet1cd >(), and preverse().

p16uc_REVERSE64 [2/2]

Packet16uc Eigen::internal::p16uc_REVERSE64 = { 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 }

static

p16uc_TRANSPOSE64_HI [1/2]

Packet16uc Eigen::internal::p16uc_TRANSPOSE64_HI = p16uc_PSET64_HI + p16uc_HALF64_0_16

static

Referenced by ptranspose(), and ptranspose().

p16uc_TRANSPOSE64_HI [2/2]

Packet16uc Eigen::internal::p16uc_TRANSPOSE64_HI = { 0,1,2,3, 4,5,6,7, 16,17,18,19, 20,21,22,23}

static

p16uc_TRANSPOSE64_LO [1/2]

Packet16uc Eigen::internal::p16uc_TRANSPOSE64_LO = p16uc_PSET64_LO + p16uc_HALF64_0_16

static

Referenced by ptranspose(), and ptranspose().

p16uc_TRANSPOSE64_LO [2/2]

Packet16uc Eigen::internal::p16uc_TRANSPOSE64_LO = { 8,9,10,11, 12,13,14,15, 24,25,26,27, 28,29,30,31}

static

p2d_COUNTDOWN

Packet2d Eigen::internal::p2d_COUNTDOWN = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet16uc>(p2d_ZERO), reinterpret_cast<Packet16uc>(p2d_ONE), 8))

static

Referenced by plset< Packet2d >().

p2d_ONE

Packet2d Eigen::internal::p2d_ONE = { 1.0, 1.0 }

static

p2d_ZERO_

Packet2d Eigen::internal::p2d_ZERO_ = { -0.0, -0.0 }

static

Referenced by pdiv< Packet1cd >().

p2ul_CONJ_XOR1

Packet2ul Eigen::internal::p2ul_CONJ_XOR1 = (Packet2ul) vec_sld((Packet4ui) p2d_ZERO_, (Packet4ui) p2l_ZERO, 8)

static

Referenced by pmul< Packet1cd >().

p2ul_CONJ_XOR2

Packet2ul Eigen::internal::p2ul_CONJ_XOR2 = (Packet2ul) vec_sld((Packet4ui) p2l_ZERO, (Packet4ui) p2d_ZERO_, 8)

static

Referenced by pconj().

p4f_COUNTDOWN [1/2]

Packet4f Eigen::internal::p4f_COUNTDOWN = { 0.0, 1.0, 2.0, 3.0 }

static

Referenced by plset< Packet4f >().

p4f_COUNTDOWN [2/2]

Packet4f Eigen::internal::p4f_COUNTDOWN = { 0.0, 1.0, 2.0, 3.0 }

static

p4f_MZERO

Packet4f Eigen::internal::p4f_MZERO = (Packet4f) vec_sl((Packet4ui)p4i_MINUS1, (Packet4ui)p4i_MINUS1)

static

Referenced by pdiv< Packet4f >(), and pmul< Packet4f >().

p4f_ONE

Packet4f Eigen::internal::p4f_ONE = vec_ctf(p4i_ONE, 0)

static

Referenced by pdiv< Packet4f >().

p4i_COUNTDOWN [1/2]

Packet4i Eigen::internal::p4i_COUNTDOWN = { 0, 1, 2, 3 }

static

Referenced by plset< Packet4i >().

p4i_COUNTDOWN [2/2]

Packet4i Eigen::internal::p4i_COUNTDOWN = { 0, 1, 2, 3 }

static

p4ui_CONJ_XOR

uint32x4_t Eigen::internal::p4ui_CONJ_XOR = vec_mergeh((Packet4ui)p4i_ZERO, (Packet4ui)p4f_MZERO)

inlinestatic

Referenced by pconj(), and pmul< Packet2cf >().

y

const Scalar & Eigen::internal::y

Initial value:

{
  return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(x, y)

Referenced by Eigen::MatrixBase< Homogeneous< MatrixType, _Direction > >::applyOnTheRight(), bicgstab(), conservative_sparse_sparse_product_impl(), Eigen::numext::equal_strict(), Eigen::numext::equal_strict(), Eigen::numext::equal_strict(), Eigen::internal::scalar_fuzzy_impl< bool >::isApprox(), Eigen::internal::scalar_fuzzy_default_impl< Scalar, false, true >::isApprox(), Eigen::internal::scalar_fuzzy_default_impl< Scalar, false, false >::isApprox(), Eigen::internal::scalar_fuzzy_default_impl< Scalar, true, false >::isApprox(), isApprox(), Eigen::internal::scalar_fuzzy_impl< bool >::isApproxOrLessThan(), Eigen::internal::scalar_fuzzy_default_impl< Scalar, false, true >::isApproxOrLessThan(), Eigen::internal::scalar_fuzzy_default_impl< Scalar, false, false >::isApproxOrLessThan(), isApproxOrLessThan(), Eigen::internal::scalar_fuzzy_default_impl< Scalar, false, false >::isMuchSmallerThan(), Eigen::internal::scalar_fuzzy_default_impl< Scalar, true, false >::isMuchSmallerThan(), isMuchSmallerThan(), llt_rank_update_lower(), Eigen::numext::not_equal_strict(), Eigen::numext::not_equal_strict(), Eigen::numext::not_equal_strict(), Eigen::internal::scalar_hypot_op< Scalar, Scalar >::operator()(), pcos< Packet4f >(), pexp< Packet4f >(), pexp< Packet8f >(), plog< Packet4f >(), plog< Packet8f >(), Eigen::internal::conj_helper< LhsScalar, RhsScalar, ConjLhs, ConjRhs >::pmadd(), Eigen::internal::conj_helper< Packet1cd, Packet1cd, false, true >::pmadd(), Eigen::internal::conj_helper< Packet1cd, Packet1cd, true, false >::pmadd(), Eigen::internal::conj_helper< Packet1cd, Packet1cd, true, true >::pmadd(), Eigen::internal::conj_helper< Packet2cd, Packet2cd, false, true >::pmadd(), Eigen::internal::conj_helper< Packet2cd, Packet2cd, true, false >::pmadd(), Eigen::internal::conj_helper< Packet2cd, Packet2cd, true, true >::pmadd(), Eigen::internal::conj_helper< Packet2cf, Packet2cf, false, true >::pmadd(), Eigen::internal::conj_helper< Packet2cf, Packet2cf, true, false >::pmadd(), Eigen::internal::conj_helper< Packet2cf, Packet2cf, true, true >::pmadd(), Eigen::internal::conj_helper< Packet4cf, Packet4cf, false, true >::pmadd(), Eigen::internal::conj_helper< Packet4cf, Packet4cf, true, false >::pmadd(), Eigen::internal::conj_helper< Packet4cf, Packet4cf, true, true >::pmadd(), Eigen::internal::conj_helper< RealScalar, std::complex< RealScalar >, false, Conj >::pmadd(), Eigen::internal::conj_helper< std::complex< RealScalar >, RealScalar, Conj, false >::pmadd(), Eigen::internal::conj_helper< Scalar, Scalar, false, false >::pmadd(), Eigen::internal::conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, false, true >::pmadd(), Eigen::internal::conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, true, false >::pmadd(), Eigen::internal::conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, true, true >::pmadd(), Eigen::internal::conj_helper< LhsScalar, RhsScalar, ConjLhs, ConjRhs >::pmul(), Eigen::internal::conj_helper< RealScalar, std::complex< RealScalar >, false, Conj >::pmul(), Eigen::internal::conj_helper< std::complex< RealScalar >, RealScalar, Conj, false >::pmul(), Eigen::internal::conj_helper< Scalar, Scalar, false, false >::pmul(), Eigen::internal::conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, false, true >::pmul(), Eigen::internal::conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, true, false >::pmul(), Eigen::internal::conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, true, true >::pmul(), positive_real_hypot(), psin< Packet4f >(), Eigen::internal::isApprox_selector< Derived, OtherDerived, true >::run(), Eigen::internal::isApprox_selector< Derived, OtherDerived, is_integer >::run(), Eigen::internal::isMuchSmallerThan_object_selector< Derived, OtherDerived, is_integer >::run(), Eigen::internal::isMuchSmallerThan_scalar_selector< Derived, is_integer >::run(), Eigen::internal::random_default_impl< half, false, false >::run(), Eigen::internal::random_default_impl< Scalar, false, false >::run(), Eigen::internal::random_default_impl< Scalar, false, true >::run(), Eigen::internal::random_default_impl< Scalar, true, false >::run(), Eigen::internal::hypot_impl< Scalar >::run(), Eigen::internal::pow_impl< ScalarX, ScalarY, IsInteger >::run(), Eigen::internal::apply_rotation_in_the_plane_selector< Scalar, OtherScalar, SizeAtCompileTime, MinAlignment, Vectorizable >::run(), Eigen::internal::apply_rotation_in_the_plane_selector< Scalar, OtherScalar, SizeAtCompileTime, MinAlignment, true >::run(), Eigen::internal::pow_impl< ScalarX, ScalarY, true >::run(), and sparse_sparse_to_dense_product_impl().