Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
Eigen::internal Namespace Reference

Namespaces

 Colamd
 
 detail
 
 group_theory
 
 std_fallback
 

Classes

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

Typedefs

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

Enumerations

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

Functions

template<typename Packet >
EIGEN_STRONG_INLINE __UNPACK_TYPE__ (Packet) pfirst_common(const Packet &a)
 
static _EIGEN_DECLARE_CONST_FAST_Packet16uc (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)
 
static _EIGEN_DECLARE_CONST_FAST_Packet4f (ZERO, 0)
 
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)
 
static _EIGEN_DECLARE_CONST_FAST_Packet4i (ZERO, 0)
 
static _EIGEN_DECLARE_CONST_FAST_Packet4i (ONE, 1)
 
static _EIGEN_DECLARE_CONST_FAST_Packet4i (MINUS1,-1)
 
static _EIGEN_DECLARE_CONST_FAST_Packet4ui (SIGN, 0x80000000u)
 
static _EIGEN_DECLARE_CONST_FAST_Packet4ui (PREV0DOT5, 0x3EFFFFFFu)
 
static _EIGEN_DECLARE_CONST_FAST_Packet8us (ONE, 1)
 
static _EIGEN_DECLARE_CONST_Packet2d (1, 1.0)
 
static _EIGEN_DECLARE_CONST_Packet2d (2, 2.0)
 
static _EIGEN_DECLARE_CONST_Packet2d (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)
 
static _EIGEN_DECLARE_CONST_Packet4f (1, 1.0f)
 
static _EIGEN_DECLARE_CONST_Packet4f (half, 0.5f)
 
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)
 
static _EIGEN_DECLARE_CONST_Packet4f_FROM_INT (inv_mant_mask, ~0x7f800000)
 
static _EIGEN_DECLARE_CONST_Packet4f_FROM_INT (min_norm_pos, 0x00800000)
 
static _EIGEN_DECLARE_CONST_Packet4f_FROM_INT (minus_inf, 0xff800000)
 
static _EIGEN_DECLARE_CONST_Packet4f_FROM_INT (minus_nan, 0xffffffff)
 
static _EIGEN_DECLARE_CONST_Packet4i (0x7f, 0x7f)
 
static _EIGEN_DECLARE_CONST_Packet4i (23, 23)
 
template<typename Packet >
EIGEN_STRONG_INLINE void absolute_split (const Packet &x, Packet &n, Packet &r)
 
template<typename T >
EIGEN_DEVICE_FUNC void aligned_delete (T *ptr, std::size_t size)
 
EIGEN_DEVICE_FUNC void aligned_free (void *ptr)
 
EIGEN_DEVICE_FUNC void * aligned_malloc (std::size_t size)
 
template<typename T >
EIGEN_DEVICE_FUNC Taligned_new (std::size_t size)
 
void * aligned_realloc (void *ptr, std::size_t new_size, std::size_t old_size)
 
template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool all_indices_known_statically ()
 
template<typename T >
T amd_flip (const T &i)
 
template<typename T0 , typename T1 >
void amd_mark (const T0 *w, const T1 &j)
 
template<typename T0 , typename T1 >
bool amd_marked (const T0 *w, const T1 &j)
 
template<typename T >
T amd_unflip (const T &i)
 
template<typename T , typename Bits , typename Func >
T apply_bit_op (Bits a, Bits b, Func f)
 
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 VectorX , typename VectorY , typename OtherScalar >
EIGEN_DEVICE_FUNC void apply_rotation_in_the_plane (DenseBase< VectorX > &xpr_x, DenseBase< VectorY > &xpr_y, const JacobiRotation< OtherScalar > &j)
 
template<typename Op , typename A , std::size_t N>
constexpr EIGEN_STRONG_INLINE array< decltype(Op::run(A())), Narray_apply (array< A, N > a)
 
template<typename Reducer , typename Op , typename A , std::size_t N>
constexpr EIGEN_STRONG_INLINE auto array_apply_and_reduce (array< A, N > a) -> decltype(h_array_apply_and_reduce< Reducer, Op, A, N >(a, typename gen_numeric_list< int, N >::type()))
 
template<DenseIndex n, typename Index , std::size_t Rank>
const Index array_get (DimensionList< Index, Rank > &)
 
template<DenseIndex n, typename Index , std::size_t Rank>
const Index array_get (const DimensionList< Index, Rank > &)
 
template<std::size_t I_, class T >
constexpr Tarray_get (std::vector< T > &a)
 
template<std::size_t I_, class T >
constexpr T && array_get (std::vector< T > &&a)
 
template<std::size_t I_, class T >
constexpr T const & array_get (std::vector< T > const &a)
 
template<std::size_t n, typename T , T a, T... as>
constexpr T array_get (const numeric_list< T, a, as... > &)
 
template<std::size_t I_, class T , std::size_t N>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tarray_get (array< T, N > &a)
 
template<std::size_t I_, class T , std::size_t N>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Tarray_get (const array< T, N > &a)
 
template<std::ptrdiff_t n, typename std::ptrdiff_t... Indices>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t array_get (const Sizes< Indices... > &)
 
template<std::ptrdiff_t n>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t array_get (const Sizes<> &)
 
template<typename std::ptrdiff_t... Indices>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t array_prod (const Sizes< Indices... > &)
 
template<typename T , std::size_t N>
EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE auto array_prod (const array< T, N > &arr) -> decltype(array_reduce< product_op, T, N >(arr, static_cast< T >(1)))
 
template<typename t >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINEarray_prod (const std::vector< t > &a)
 
template<typename Reducer , typename T , std::size_t N>
EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE auto array_reduce (const array< T, N > &arr, T identity) -> decltype(h_array_reduce< Reducer, T, N >::run(arr, identity))
 
template<typename T , std::size_t N>
constexpr EIGEN_STRONG_INLINE array< T, Narray_reverse (array< T, N > arr)
 
template<typename T , std::size_t N>
EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE auto array_sum (const array< T, N > &arr) -> decltype(array_reduce< sum_op, T, N >(arr, static_cast< T >(0)))
 
template<typename Op , typename A , typename B , std::size_t N>
constexpr EIGEN_STRONG_INLINE array< decltype(Op::run(A(), B())), Narray_zip (array< A, N > a, array< B, N > b)
 
template<typename Reducer , typename Op , typename A , typename B , std::size_t N>
constexpr EIGEN_STRONG_INLINE auto array_zip_and_reduce (array< A, N > a, array< B, N > b) -> decltype(h_array_zip_and_reduce< Reducer, Op, A, B, N >(a, b, typename gen_numeric_list< int, N >::type()))
 
template<typename DstXprType , typename SrcXprType >
void assign_sparse_to_sparse (DstXprType &dst, const SrcXprType &src)
 
template<typename MatrixType >
SluMatrix asSluMatrix (MatrixType &mat)
 
template<typename Packet >
EIGEN_ALWAYS_INLINE void band (PacketBlock< Packet, 4 > &acc, const Packet &pMask)
 
template<typename Packet , typename Packetc >
EIGEN_ALWAYS_INLINE void bcouple (PacketBlock< Packet, 4 > &taccReal, PacketBlock< Packet, 4 > &taccImag, PacketBlock< Packetc, 8 > &tRes, PacketBlock< Packetc, 4 > &acc1, PacketBlock< Packetc, 4 > &acc2)
 
template<typename Packet , typename Packetc >
EIGEN_ALWAYS_INLINE void bcouple (PacketBlock< Packet, 1 > &taccReal, PacketBlock< Packet, 1 > &taccImag, PacketBlock< Packetc, 2 > &tRes, PacketBlock< Packetc, 1 > &acc1, PacketBlock< Packetc, 1 > &acc2)
 
template<typename Packet , typename Packetc >
EIGEN_ALWAYS_INLINE void bcouple_common (PacketBlock< Packet, 4 > &taccReal, PacketBlock< Packet, 4 > &taccImag, PacketBlock< Packetc, 4 > &acc1, PacketBlock< Packetc, 4 > &acc2)
 
template<typename Packet , typename Packetc >
EIGEN_ALWAYS_INLINE void bcouple_common (PacketBlock< Packet, 1 > &taccReal, PacketBlock< Packet, 1 > &taccImag, PacketBlock< Packetc, 1 > &acc1, PacketBlock< Packetc, 1 > &acc2)
 
template<>
EIGEN_ALWAYS_INLINE void bcouple_common< Packet2d, Packet1cd > (PacketBlock< Packet2d, 4 > &taccReal, PacketBlock< Packet2d, 4 > &taccImag, PacketBlock< Packet1cd, 4 > &acc1, PacketBlock< Packet1cd, 4 > &acc2)
 
template<>
EIGEN_ALWAYS_INLINE void bcouple_common< Packet2d, Packet1cd > (PacketBlock< Packet2d, 1 > &taccReal, PacketBlock< Packet2d, 1 > &taccImag, PacketBlock< Packet1cd, 1 > &acc1, PacketBlock< Packet1cd, 1 > &acc2)
 
EIGEN_STRONG_INLINE Packet8f Bf16ToF32 (const Packet8bf &a)
 
EIGEN_STRONG_INLINE Packet16f Bf16ToF32 (const Packet16bf &a)
 
EIGEN_STRONG_INLINE Packet4f Bf16ToF32 (const Packet4bf &p)
 
EIGEN_STRONG_INLINE Packet4f Bf16ToF32Even (const Packet8bf &bf)
 
EIGEN_STRONG_INLINE Packet4f Bf16ToF32Odd (const Packet8bf &bf)
 
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 T >
bool biteq (T a, T b)
 
template<typename T >
Map< const Array< unsigned char, sizeof(T), 1 > > bits (const T &x)
 
template<typename DataMapper , typename Packet , typename Index , const Index accCols, int N, int StorageOrder>
EIGEN_ALWAYS_INLINE void bload (PacketBlock< Packet, 4 > &acc, const DataMapper &res, Index row, Index col)
 
template<typename DataMapper , typename Packet , typename Index , const Index accCols, int N, int StorageOrder>
EIGEN_ALWAYS_INLINE void bload (PacketBlock< Packet, 8 > &acc, const DataMapper &res, Index row, Index col)
 
template<typename DataMapper , typename Packet , typename Index , const Index accCols, int N, int StorageOrder>
EIGEN_ALWAYS_INLINE void bload (PacketBlock< Packet, 2 > &acc, const DataMapper &res, Index row, Index col)
 
template<typename MatrixType , Index Alignment>
void BlockedInPlaceTranspose (MatrixType &m)
 
template<typename Derived >
NumTraits< typename traits< Derived >::Scalar >::Real blueNorm_impl (const EigenBase< Derived > &_vec)
 
template<typename Packet >
EIGEN_ALWAYS_INLINE Packet bmask (const int remaining_rows)
 
template<>
EIGEN_ALWAYS_INLINE Packet2d bmask< Packet2d > (const int remaining_rows)
 
template<typename Derived >
EIGEN_DEVICE_FUNC const Derived::Scalar bruteforce_det3_helper (const MatrixBase< Derived > &matrix, int a, int b, int c)
 
template<typename Packet >
EIGEN_ALWAYS_INLINE void bscale (PacketBlock< Packet, 4 > &acc, PacketBlock< Packet, 4 > &accZ, const Packet &pAlpha)
 
template<typename Packet >
EIGEN_ALWAYS_INLINE void bscale (PacketBlock< Packet, 1 > &acc, PacketBlock< Packet, 1 > &accZ, const Packet &pAlpha)
 
template<typename Packet >
EIGEN_ALWAYS_INLINE void bscale (PacketBlock< Packet, 4 > &acc, PacketBlock< Packet, 4 > &accZ, const Packet &pAlpha, const Packet &pMask)
 
template<typename Packet , int N>
EIGEN_ALWAYS_INLINE void bscalec (PacketBlock< Packet, N > &aReal, PacketBlock< Packet, N > &aImag, const Packet &bReal, const Packet &bImag, PacketBlock< Packet, N > &cReal, PacketBlock< Packet, N > &cImag)
 
template<typename Packet >
EIGEN_ALWAYS_INLINE void bscalec (PacketBlock< Packet, 4 > &aReal, PacketBlock< Packet, 4 > &aImag, const Packet &bReal, const Packet &bImag, PacketBlock< Packet, 4 > &cReal, PacketBlock< Packet, 4 > &cImag, const Packet &pMask)
 
template<typename Packet >
EIGEN_ALWAYS_INLINE void bscalec_common (PacketBlock< Packet, 4 > &acc, PacketBlock< Packet, 4 > &accZ, const Packet &pAlpha)
 
template<typename Packet >
EIGEN_ALWAYS_INLINE void bscalec_common (PacketBlock< Packet, 1 > &acc, PacketBlock< Packet, 1 > &accZ, const Packet &pAlpha)
 
template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE void bsetzero (PacketBlock< Packet, 4 > &acc)
 
template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE void bsetzero (PacketBlock< Packet, 1 > &acc)
 
template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE void bsetzeroMMA (__vector_quad *acc)
 
template<typename MatrixType >
void c_to_fortran_numbering (MatrixType &mat)
 
template<typename Dst , template< typename > class StorageBase, typename Src , typename Func >
EIGEN_DEVICE_FUNC void call_assignment (const NoAlias< Dst, StorageBase > &dst, const Src &src, const Func &func)
 
template<typename Dst , 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 DstXprType , typename SrcXprType , typename Functor >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop (DstXprType &dst, const SrcXprType &src, const Functor &func)
 
template<typename DstXprType >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop (DstXprType &dst, const Eigen::CwiseNullaryOp< Eigen::internal::scalar_constant_op< typename DstXprType::Scalar >, DstXprType > &src, const internal::assign_op< typename DstXprType::Scalar, typename DstXprType::Scalar > &func)
 
template<typename DstXprType , typename SrcXprType >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop (DstXprType &dst, const SrcXprType &src)
 
template<typename Dst , template< typename > class StorageBase, typename Src , typename Func >
EIGEN_DEVICE_FUNC void call_restricted_packet_assignment (const NoAlias< Dst, StorageBase > &dst, const Src &src, const Func &func)
 
template<typename Dst , typename Src , typename Func >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_restricted_packet_assignment_no_alias (Dst &dst, const Src &src, const Func &func)
 
template<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<>
EIGEN_STRONG_INLINE double cast (const AnnoyingScalar &x)
 
template<>
EIGEN_STRONG_INLINE float cast (const AnnoyingScalar &x)
 
template<typename OldType , typename NewType >
EIGEN_DEVICE_FUNC NewType cast (const OldType &x)
 
EIGEN_STRONG_INLINE Packet16f cat256 (Packet8f a, Packet8f b)
 
static void check_DenseIndex_is_signed ()
 
template<typename Dst , typename Src >
void check_for_aliasing (const Dst &dst, const Src &src)
 
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void check_size_for_overflow (std::size_t size)
 
template<typename T , int Size>
EIGEN_DEVICE_FUNC void check_static_allocation_size ()
 
EIGEN_DEVICE_FUNC void check_that_malloc_is_allowed ()
 
template<typename Scalar >
void chkder (const Matrix< Scalar, Dynamic, 1 > &x, const Matrix< Scalar, Dynamic, 1 > &fvec, const Matrix< Scalar, Dynamic, Dynamic > &fjac, Matrix< Scalar, Dynamic, 1 > &xp, const Matrix< Scalar, Dynamic, 1 > &fvecp, int mode, Matrix< Scalar, Dynamic, 1 > &err)
 
template<typename _StorageIndex >
int cm_factorize_p (cholmod_sparse *A, double beta[2], _StorageIndex *fset, std::size_t fsize, cholmod_factor *L, cholmod_common &Common)
 
template<>
int cm_factorize_p< SuiteSparse_long > (cholmod_sparse *A, double beta[2], SuiteSparse_long *fset, std::size_t fsize, cholmod_factor *L, cholmod_common &Common)
 
template<typename _StorageIndex >
cholmod_dense * cm_solve (int sys, cholmod_factor &L, cholmod_dense &B, cholmod_common &Common)
 
template<>
cholmod_dense * cm_solve< SuiteSparse_long > (int sys, cholmod_factor &L, cholmod_dense &B, cholmod_common &Common)
 
template<typename _StorageIndex >
cholmod_sparse * cm_spsolve (int sys, cholmod_factor &L, cholmod_sparse &B, cholmod_common &Common)
 
template<>
cholmod_sparse * cm_spsolve< SuiteSparse_long > (int sys, cholmod_factor &L, cholmod_sparse &B, cholmod_common &Common)
 
template<typename MatrixType , int i, int j>
EIGEN_DEVICE_FUNC MatrixType::Scalar cofactor_3x3 (const MatrixType &m)
 
template<typename MatrixType , int i, int j>
EIGEN_DEVICE_FUNC MatrixType::Scalar cofactor_4x4 (const MatrixType &matrix)
 
template<typename MatrixType , typename IndexVector >
int coletree (const MatrixType &mat, IndexVector &parent, IndexVector &firstRowElt, typename MatrixType::StorageIndex *perm=0)
 
template<typename ResScalar , typename Lhs , typename Rhs >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE ResScalar combine_scalar_factors (const ResScalar &alpha, const Lhs &lhs, const Rhs &rhs)
 
template<typename ResScalar , typename Lhs , typename Rhs >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE ResScalar combine_scalar_factors (const Lhs &lhs, const Rhs &rhs)
 
template<typename T >
EIGEN_DEVICE_FUNC std::complex< Tcomplex_log (const std::complex< T > &z)
 
template<typename T >
EIGEN_DEVICE_FUNC std::complex< Tcomplex_rsqrt (const std::complex< T > &a_x)
 
template<typename T >
EIGEN_DEVICE_FUNC std::complex< Tcomplex_sqrt (const std::complex< T > &a_x)
 
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 , 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 MatrixType , typename DiagType , typename SubDiagType >
EIGEN_DEVICE_FUNC ComputationInfo computeFromTridiagonal_impl (DiagType &diag, SubDiagType &subdiag, const Index maxIterations, bool computeEigenvectors, MatrixType &eivec)
 
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. More...
 
template<typename LhsScalar , typename RhsScalar , typename Index >
void computeProductBlockingSizes (Index &k, Index &m, Index &n, Index num_threads=1)
 
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 void conditional_aligned_delete_auto (T *ptr, 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>
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<typename T , bool Align>
EIGEN_DEVICE_FUNC Tconditional_aligned_new (std::size_t size)
 
template<typename T , bool Align>
EIGEN_DEVICE_FUNC Tconditional_aligned_new_auto (std::size_t size)
 
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 , bool Align>
EIGEN_DEVICE_FUNC Tconditional_aligned_realloc_new (T *pts, std::size_t new_size, std::size_t old_size)
 
template<typename T , bool Align>
Tconditional_aligned_realloc_new_auto (T *pts, std::size_t new_size, std::size_t old_size)
 
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 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 T >
EIGEN_DEVICE_FUNC Tconst_cast_ptr (const T *ptr)
 
template<typename TMatrix , typename CMatrix , typename VectorX , typename VectorB , typename VectorF >
void constrained_cg (const TMatrix &A, const CMatrix &C, VectorX &x, const VectorB &b, const VectorF &f, IterationController &iter)
 
template<typename T >
EIGEN_DEVICE_FUNC Tconstruct_elements_of_array (T *ptr, std::size_t size)
 
template<typename IndexDest , typename IndexSrc >
EIGEN_DEVICE_FUNC IndexDest convert_index (const IndexSrc &idx)
 
bool copy_bool (bool b)
 
template<typename Scalar >
void covar (Matrix< Scalar, Dynamic, Dynamic > &r, const VectorXi &ipvt, Scalar tol=std::sqrt(NumTraits< Scalar >::epsilon()))
 
template<typename StorageIndex >
StorageIndex cs_tdfs (StorageIndex j, StorageIndex k, StorageIndex *head, const StorageIndex *next, StorageIndex *post, StorageIndex *stack)
 
template<typename StorageIndex >
static StorageIndex cs_wclear (StorageIndex mark, StorageIndex lemax, StorageIndex *w, StorageIndex n)
 
template<typename T >
EIGEN_DEVICE_FUNC void destruct_elements_of_array (T *ptr, std::size_t size)
 
template<typename Scalar >
void dogleg (const Matrix< Scalar, Dynamic, Dynamic > &qrfac, const Matrix< Scalar, Dynamic, 1 > &diag, const Matrix< Scalar, Dynamic, 1 > &qtb, Scalar delta, Matrix< Scalar, Dynamic, 1 > &x)
 
template<typename Packet >
void doubleword_reciprocal (const Packet &x, Packet &recip_hi, Packet &recip_lo)
 
 EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (assign_op, scalar_sum_op, add_assign_op)
 
 EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (add_assign_op, scalar_sum_op, add_assign_op)
 
 EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (sub_assign_op, scalar_sum_op, sub_assign_op)
 
 EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (assign_op, scalar_difference_op, sub_assign_op)
 
 EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (add_assign_op, scalar_difference_op, sub_assign_op)
 
 EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (sub_assign_op, scalar_difference_op, add_assign_op)
 
 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)
 
 EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR (sum,(Size-1) *NumTraits< Scalar >::AddCost, 1, internal::scalar_sum_op)
 
 EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR (minCoeff,(Size-1) *NumTraits< Scalar >::AddCost, 1, internal::scalar_min_op)
 
 EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR (maxCoeff,(Size-1) *NumTraits< Scalar >::AddCost, 1, internal::scalar_max_op)
 
 EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR (prod,(Size-1) *NumTraits< Scalar >::MulCost, 1, internal::scalar_product_op)
 
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (random, Scalar) random(const Scalar &x
 
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (random, Scalar) random()
 
 EIGEN_MEMBER_FUNCTOR (norm,(Size+5) *NumTraits< Scalar >::MulCost+(Size-1) *NumTraits< Scalar >::AddCost)
 
 EIGEN_MEMBER_FUNCTOR (stableNorm,(Size+5) *NumTraits< Scalar >::MulCost+(Size-1) *NumTraits< Scalar >::AddCost)
 
 EIGEN_MEMBER_FUNCTOR (blueNorm,(Size+5) *NumTraits< Scalar >::MulCost+(Size-1) *NumTraits< Scalar >::AddCost)
 
 EIGEN_MEMBER_FUNCTOR (hypotNorm,(Size-1) *functor_traits< scalar_hypot_op< Scalar > >::Cost)
 
 EIGEN_MEMBER_FUNCTOR (all,(Size-1) *NumTraits< Scalar >::AddCost)
 
 EIGEN_MEMBER_FUNCTOR (any,(Size-1) *NumTraits< Scalar >::AddCost)
 
 EIGEN_MEMBER_FUNCTOR (count,(Size-1) *NumTraits< Scalar >::AddCost)
 
static EIGEN_STRONG_INLINE int eigen_neon_shuffle_mask (int p, int q, int r, int s)
 
void eigen_pastix (pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, 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 Index , typename IndexVector >
Index etree_find (Index i, IndexVector &pp)
 
Index eval_expr_given_size (Index x, Index)
 
template<int N>
FixedInt< Neval_expr_given_size (FixedInt< N > x, Index)
 
template<typename Derived >
Index eval_expr_given_size (const symbolic::BaseExpr< Derived > &x, Index size)
 
template<typename LhsScalar , typename RhsScalar , int KcFactor, typename Index >
void evaluateProductBlockingSizesHeuristic (Index &k, Index &m, Index &n, Index num_threads=1)
 
template<int I_>
EIGEN_STRONG_INLINE Packet2d extract128 (Packet8d x)
 
template<int I_>
EIGEN_STRONG_INLINE Packet8f extract256 (Packet16f x)
 
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T::Scalarextract_data (const T &m)
 
EIGEN_STRONG_INLINE Packet4bf F32MaskToBf16Mask (const Packet4f &p)
 
EIGEN_STRONG_INLINE Packet8bf F32ToBf16 (Packet4f p4f)
 
EIGEN_STRONG_INLINE Packet8bf F32ToBf16 (const Packet8f &a)
 
EIGEN_STRONG_INLINE Packet8bf F32ToBf16 (Packet4f even, Packet4f odd)
 
EIGEN_STRONG_INLINE Packet16bf F32ToBf16 (const Packet16f &a)
 
EIGEN_STRONG_INLINE Packet4bf F32ToBf16 (const Packet4f &p)
 
EIGEN_STRONG_INLINE Packet8bf F32ToBf16Bool (Packet4f even, Packet4f odd)
 
template<typename Packet >
EIGEN_STRONG_INLINE void fast_twosum (const Packet &x, const Packet &y, Packet &s_hi, Packet &s_lo)
 
template<typename Packet >
EIGEN_STRONG_INLINE void fast_twosum (const Packet &x_hi, const Packet &x_lo, const Packet &y_hi, const Packet &y_lo, Packet &s_hi, Packet &s_lo)
 
template<typename Packet >
EIGEN_STRONG_INLINE void fast_twosum (const Packet &x, const Packet &y_hi, const Packet &y_lo, Packet &s_hi, Packet &s_lo)
 
template<typename FunctorType , typename Scalar >
DenseIndex fdjac1 (const FunctorType &Functor, Matrix< Scalar, Dynamic, 1 > &x, Matrix< Scalar, Dynamic, 1 > &fvec, Matrix< Scalar, Dynamic, Dynamic > &fjac, DenseIndex ml, DenseIndex mu, Scalar epsfcn)
 
template<typename T >
Tfftw_cast (const T *p)
 
fftw_complex * fftw_cast (const std::complex< double > *p)
 
fftwf_complex * fftw_cast (const std::complex< float > *p)
 
fftwl_complex * fftw_cast (const std::complex< long double > *p)
 
template<typename T >
EIGEN_CONSTEXPR Index first (const T &x) EIGEN_NOEXCEPT
 
template<int Alignment, typename Scalar , typename Index >
EIGEN_DEVICE_FUNC Index first_aligned (const Scalar *array, Index size)
 
template<int Alignment, typename Derived >
static Index first_aligned (const DenseBase< Derived > &m)
 
template<typename Scalar , typename Index >
EIGEN_DEVICE_FUNC Index first_default_aligned (const Scalar *array, Index size)
 
template<typename Derived >
static Index first_default_aligned (const DenseBase< Derived > &m)
 
template<typename Index >
Index first_multiple (Index size, Index base)
 
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T flipsign (const T &should_flipsign, const T &x)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double flipsign< double > (const double &should_flipsign, const double &x)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float flipsign< float > (const float &should_flipsign, const float &x)
 
EIGEN_STRONG_INLINE Packet8h float2half (const Packet8f &a)
 
EIGEN_STRONG_INLINE Packet16h float2half (const Packet16f &a)
 
template<typename MatrixType >
void fortran_to_c_numbering (MatrixType &mat)
 
template<typename Scalar , typename Index , typename Packet , typename RhsPacket , typename DataMapper , const Index accRows, const Index accCols>
EIGEN_STRONG_INLINE void gemm (const DataMapper &res, const Scalar *blockA, const Scalar *blockB, Index rows, Index depth, Index cols, Scalar alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
 
template<typename LhsScalar , typename RhsScalar , typename Scalarc , typename Scalar , typename Index , typename Packet , typename Packetc , typename RhsPacket , typename DataMapper , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE void gemm_complex (const DataMapper &res, const LhsScalar *blockAc, const RhsScalar *blockBc, Index rows, Index depth, Index cols, Scalarc alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
 
template<typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE void gemm_complex_extra_col (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index strideB, Index row, Index col, Index remaining_rows, Index remaining_cols, const Packet &pAlphaReal, const Packet &pAlphaImag)
 
template<typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE void gemm_complex_extra_row (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index strideB, Index row, Index col, Index rows, Index cols, Index remaining_rows, const Packet &pAlphaReal, const Packet &pAlphaImag, const Packet &pMask)
 
template<typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE void gemm_complex_unrolled_col (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index strideB, Index &row, Index rows, Index col, Index remaining_cols, const Packet &pAlphaReal, const Packet &pAlphaImag)
 
template<int unroll_factor, typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE void gemm_complex_unrolled_col_iteration (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index strideB, Index &row, Index col, Index remaining_cols, const Packet &pAlphaReal, const Packet &pAlphaImag)
 
template<int unroll_factor, typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE void gemm_complex_unrolled_iteration (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index strideB, Index &row, Index col, const Packet &pAlphaReal, const Packet &pAlphaImag)
 
template<int unroll_factor, typename Scalar , typename Packet , typename Packetc , typename RhsPacket , typename DataMapper , typename Index , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE void gemm_complex_unrolled_MMA_iteration (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index strideB, Index &row, Index col, const Packet &pAlphaReal, const Packet &pAlphaImag)
 
template<typename LhsScalar , typename RhsScalar , typename Scalarc , typename Scalar , typename Index , typename Packet , typename Packetc , typename RhsPacket , typename DataMapper , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
void gemm_complexMMA (const DataMapper &res, const LhsScalar *blockAc, const RhsScalar *blockBc, Index rows, Index depth, Index cols, Scalarc alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
 
template<typename Scalar , typename Packet , typename DataMapper , typename Index , const Index accRows>
EIGEN_STRONG_INLINE void gemm_extra_col (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index row, Index col, Index remaining_rows, Index remaining_cols, const Packet &pAlpha)
 
template<typename Scalar , typename Packet , typename DataMapper , typename Index , const Index accRows, const Index accCols>
EIGEN_STRONG_INLINE void gemm_extra_row (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index row, Index col, Index rows, Index cols, Index remaining_rows, const Packet &pAlpha, const Packet &pMask)
 
template<typename Scalar , typename Packet , typename DataMapper , typename Index , const Index accCols>
EIGEN_STRONG_INLINE void gemm_unrolled_col (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index &row, Index rows, Index col, Index remaining_cols, const Packet &pAlpha)
 
template<int unroll_factor, typename Scalar , typename Packet , typename DataMapper , typename Index , const Index accCols>
EIGEN_STRONG_INLINE void gemm_unrolled_col_iteration (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index &row, Index col, Index remaining_cols, const Packet &pAlpha)
 
template<int unroll_factor, typename Scalar , typename Packet , typename DataMapper , typename Index , const Index accRows, const Index accCols>
EIGEN_STRONG_INLINE void gemm_unrolled_iteration (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index &row, Index col, const Packet &pAlpha)
 
template<int unroll_factor, typename Scalar , typename Packet , typename RhsPacket , typename DataMapper , typename Index , const Index accRows, const Index accCols>
EIGEN_STRONG_INLINE void gemm_unrolled_MMA_iteration (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index &row, Index col, const Packet &pAlpha)
 
template<typename Scalar , typename Index , typename Packet , typename RhsPacket , typename DataMapper , const Index accRows, const Index accCols>
void gemmMMA (const DataMapper &res, const Scalar *blockA, const Scalar *blockB, Index rows, Index depth, Index cols, Scalar alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
 
template<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 Packet >
Packet generic_expm1 (const Packet &x)
 
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T generic_fast_erf_float (const T &a_x)
 
template<typename T >
T generic_fast_tanh_float (const T &a_x)
 
template<typename T , typename ScalarType >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T generic_ndtri (const T &a)
 
template<typename T , typename ScalarType >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T generic_ndtri_gt_exp_neg_two (const T &b)
 
template<typename T , typename ScalarType >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T generic_ndtri_lt_exp_neg_two (const T &b, const T &should_flipsign)
 
template<typename Packet >
Packet generic_plog1p (const Packet &x)
 
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet generic_pow (const Packet &x, const Packet &y)
 
template<typename Packet >
EIGEN_STRONG_INLINE Packet generic_pow_impl (const Packet &x, const Packet &y)
 
template<typename SizeType >
Index get_runtime_reshape_size (SizeType size, Index, Index)
 
Index get_runtime_reshape_size (AutoSize_t, Index other, Index total)
 
template<typename T >
EIGEN_DEVICE_FUNC Index get_runtime_value (const T &x)
 
template<int N>
EIGEN_DEVICE_FUNC Index get_runtime_value (FixedInt< N >(*)())
 
template<typename Scalar , typename Index , int StorageOrder>
EIGEN_ALWAYS_INLINE std::complex< ScalargetAdjointVal (Index i, Index j, const_blas_data_mapper< std::complex< Scalar >, Index, StorageOrder > &dt)
 
template<typename Scalar , typename StorageIndex >
void GetMarketLine (const char *line, StorageIndex &i, StorageIndex &j, Scalar &value)
 
template<>
void GetMarketLine (const char *line, int &i, int &j, float &value)
 
template<>
void GetMarketLine (const char *line, int &i, int &j, double &value)
 
template<>
void GetMarketLine (const char *line, int &i, int &j, std::complex< float > &value)
 
template<>
void GetMarketLine (const char *line, int &i, int &j, std::complex< double > &value)
 
template<typename Scalar , typename StorageIndex >
void GetMarketLine (const char *line, StorageIndex &i, StorageIndex &j, std::complex< Scalar > &value)
 
template<typename RealScalar >
void GetVectorElt (const std::string &line, RealScalar &val)
 
template<typename RealScalar >
void GetVectorElt (const std::string &line, std::complex< RealScalar > &val)
 
template<typename MatrixType , typename Rhs , typename Dest , typename Preconditioner >
bool gmres (const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, Index &iters, const Index &restart, typename Dest::RealScalar &tol_error)
 
template<typename Op , typename A , std::size_t N, int... n>
constexpr EIGEN_STRONG_INLINE array< decltype(Op::run(A())), Nh_array_apply (array< A, N > a, numeric_list< int, n... >)
 
template<typename Reducer , typename Op , typename A , std::size_t N, int... n>
constexpr EIGEN_STRONG_INLINE auto h_array_apply_and_reduce (array< A, N > arr, numeric_list< int, n... >) -> decltype(reduce< Reducer, typename id_numeric< int, n, decltype(Op::run(A()))>::type... >::run(Op::run(array_get< n >(arr))...))
 
template<typename Array , int... n>
constexpr EIGEN_STRONG_INLINE Array h_array_reverse (Array arr, numeric_list< int, n... >)
 
template<typename Op , typename A , typename B , std::size_t N, int... n>
constexpr EIGEN_STRONG_INLINE array< decltype(Op::run(A(), B())), Nh_array_zip (array< A, N > a, array< B, N > b, numeric_list< int, n... >)
 
template<typename Reducer , typename Op , typename A , typename B , std::size_t N, int... n>
constexpr EIGEN_STRONG_INLINE auto h_array_zip_and_reduce (array< A, N > a, array< B, N > b, numeric_list< int, n... >) -> decltype(reduce< Reducer, typename id_numeric< int, n, decltype(Op::run(A(), B()))>::type... >::run(Op::run(array_get< n >(a), array_get< n >(b))...))
 
EIGEN_STRONG_INLINE Packet8f half2float (const Packet8h &a)
 
EIGEN_STRONG_INLINE Packet16f half2float (const Packet16h &a)
 
EIGEN_DEVICE_FUNC void handmade_aligned_free (void *ptr)
 
EIGEN_DEVICE_FUNC void * handmade_aligned_malloc (std::size_t size, std::size_t alignment=EIGEN_DEFAULT_ALIGN_BYTES)
 
void * handmade_aligned_realloc (void *ptr, std::size_t size, std::size_t=0)
 
template<typename MatrixQR , typename HCoeffs >
void householder_qr_inplace_unblocked (MatrixQR &mat, HCoeffs &hCoeffs, typename MatrixQR::Scalar *tempData=0)
 
template<typename MatrixType , typename Rhs , typename Dest , typename Preconditioner >
bool idrs (const MatrixType &A, const Rhs &b, Dest &x, const Preconditioner &precond, Index &iter, typename Dest::RealScalar &relres, Index S, bool smoothing, typename Dest::RealScalar angle, bool replacement)
 
template<typename Scalar , IgammaComputationMode mode>
EIGEN_DEVICE_FUNC int igamma_num_iterations ()
 
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ignore_unused_variable (const T &)
 
template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool index_known_statically (Index i)
 
template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool index_pair_first_statically_eq (Index i, Index value)
 
template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool index_pair_second_statically_eq (Index i, Index value)
 
template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool index_statically_eq (Index i, Index value)
 
template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool index_statically_gt (Index i, Index value)
 
template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool index_statically_lt (Index i, Index value)
 
template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool index_statically_ne (Index i, Index value)
 
template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool indices_statically_known_to_increase ()
 
template<class InstType , typename ArrType , std::size_t N, bool Reverse = false>
InstType instantiate_by_c_array (ArrType *arr)
 
template<typename BVH , typename Intersector >
bool intersect_helper (const BVH &tree, Intersector &intersector, typename BVH::Index root)
 
template<typename T1 , typename T2 >
EIGEN_DEVICE_FUNC bool is_same_dense (const T1 &mat1, const T2 &mat2, typename enable_if< possibly_same_dense< T1, T2 >::value >::type *=0)
 
template<typename T1 , typename T2 >
EIGEN_DEVICE_FUNC bool is_same_dense (const T1 &, const T2 &, typename enable_if<!possibly_same_dense< T1, T2 >::value >::type *=0)
 
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 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 bool isfinite_impl (const std::complex< T > &x)
 
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)&&(!NumTraits< T >::IsComplex), bool >::type isinf_impl (const T &x)
 
template<typename T >
EIGEN_DEVICE_FUNC bool isinf_impl (const std::complex< T > &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 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)&&(!NumTraits< T >::IsComplex), bool >::type isnan_impl (const T &x)
 
template<typename T >
EIGEN_DEVICE_FUNC bool isnan_impl (const std::complex< T > &x)
 
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 MatrixType , typename VectorType >
static Index llt_rank_update_lower (MatrixType &mat, const VectorType &vec, const typename MatrixType::RealScalar &sigma)
 
template<typename Scalar >
void lmpar (Matrix< Scalar, Dynamic, Dynamic > &r, const VectorXi &ipvt, const Matrix< Scalar, Dynamic, 1 > &diag, const Matrix< Scalar, Dynamic, 1 > &qtb, Scalar delta, Scalar &par, Matrix< Scalar, Dynamic, 1 > &x)
 
template<typename QRSolver , typename VectorType >
void lmpar2 (const QRSolver &qr, const VectorType &diag, const VectorType &qtb, typename VectorType::Scalar m_delta, typename VectorType::Scalar &par, VectorType &x)
 
template<typename Scalar >
void lmpar2 (const ColPivHouseholderQR< Matrix< Scalar, Dynamic, Dynamic > > &qr, const Matrix< Scalar, Dynamic, 1 > &diag, const Matrix< Scalar, Dynamic, 1 > &qtb, Scalar delta, Scalar &par, Matrix< Scalar, Dynamic, 1 > &x)
 
template<typename Scalar , int Rows, int Cols, typename PermIndex >
void lmqrsolv (Matrix< Scalar, Rows, Cols > &s, const PermutationMatrix< Dynamic, Dynamic, PermIndex > &iPerm, const Matrix< Scalar, Dynamic, 1 > &diag, const Matrix< Scalar, Dynamic, 1 > &qtb, Matrix< Scalar, Dynamic, 1 > &x, Matrix< Scalar, Dynamic, 1 > &sdiag)
 
template<typename Scalar , int _Options, typename Index >
void lmqrsolv (SparseMatrix< Scalar, _Options, Index > &s, const PermutationMatrix< Dynamic, Dynamic > &iPerm, const Matrix< Scalar, Dynamic, 1 > &diag, const Matrix< Scalar, Dynamic, 1 > &qtb, Matrix< Scalar, Dynamic, 1 > &x, Matrix< Scalar, Dynamic, 1 > &sdiag)
 
template<typename Scalar , typename Packet , typename Index >
EIGEN_ALWAYS_INLINE void loadPacketRemaining (const Scalar *lhs, Packet &lhsV, Index remaining_rows)
 
template<typename Scalar , typename Packet , typename Index , bool LhsIsReal>
EIGEN_ALWAYS_INLINE void loadPacketRemaining (const Scalar *lhs_ptr, const Scalar *lhs_ptr_imag, Packet &lhsV, Packet &lhsVi, Index remaining_rows)
 
template<typename Scalar , typename RealPacket >
void loadQuadToDoublePacket (const Scalar *b, DoublePacket< RealPacket > &dest, typename enable_if< unpacket_traits< RealPacket >::size<=8 >::type *=0)
 
template<typename Scalar , typename RealPacket >
void loadQuadToDoublePacket (const Scalar *b, DoublePacket< RealPacket > &dest, typename enable_if< unpacket_traits< RealPacket >::size==16 >::type *=0)
 
Index LUnumTempV (Index &m, Index &w, Index &t, Index &b)
 
template<typename Scalar >
Index LUTempSpace (Index &m, Index &w)
 
template<typename Scalar >
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar main_igamma_term (Scalar a, Scalar x)
 
template<typename TriangularFactorType , typename VectorsType , typename CoeffsType >
void make_block_householder_triangular_factor (TriangularFactorType &triFactor, const VectorsType &vectors, const CoeffsType &hCoeffs)
 
template<typename A , typename B >
void make_coherent (const A &a, const B &b)
 
template<typename BinOp , typename A , typename B , typename RefType >
void make_coherent_expression (CwiseBinaryOp< BinOp, A, B > xpr, const RefType &ref)
 
template<typename UnaryOp , typename A , typename RefType >
void make_coherent_expression (const CwiseUnaryOp< UnaryOp, A > &xpr, const RefType &ref)
 
template<typename UnaryOp , typename A , typename RefType >
void make_coherent_expression (const CwiseNullaryOp< UnaryOp, A > &, const RefType &)
 
template<typename T , typename Q >
const TmakeIndexedViewCompatible (const T &x, Index, Q)
 
template<typename T >
enable_if< symbolic::is_symbolic< T >::value, SingleRange >::type makeIndexedViewCompatible (const T &id, Index size, SpecializedType)
 
template<typename XprSizeType >
AllRange< get_fixed_value< XprSizeType >::value > makeIndexedViewCompatible (all_t, XprSizeType size, SpecializedType)
 
template<typename FirstType , typename SizeType , typename IncrType >
ArithmeticSequence< Index, typename make_size_type< SizeType >::type, IncrType > makeIndexedViewCompatible (const ArithmeticSequence< FirstType, SizeType, IncrType > &ids, Index size, SpecializedType)
 
void manage_caching_sizes (Action action, std::ptrdiff_t *l1, std::ptrdiff_t *l2, std::ptrdiff_t *l3)
 
std::ptrdiff_t manage_caching_sizes_helper (std::ptrdiff_t a, std::ptrdiff_t b)
 
void manage_multi_threading (Action action, int *v)
 
template<typename Scalar , int Flags, typename Index >
MappedSparseMatrix< Scalar, Flags, Indexmap_superlu (SluMatrix &sluMat)
 
template<typename ArgType , typename ResultType >
void matrix_exp_compute (const ArgType &arg, ResultType &result, true_type)
 
template<typename ArgType , typename ResultType >
void matrix_exp_compute (const ArgType &arg, ResultType &result, false_type)
 
template<typename MatA , typename MatU , typename MatV >
void matrix_exp_pade13 (const MatA &A, MatU &U, MatV &V)
 Compute the (13,13)-Padé approximant to the exponential. More...
 
template<typename MatA , typename MatU , typename MatV >
void matrix_exp_pade3 (const MatA &A, MatU &U, MatV &V)
 Compute the (3,3)-Padé approximant to the exponential. More...
 
template<typename MatA , typename MatU , typename MatV >
void matrix_exp_pade5 (const MatA &A, MatU &U, MatV &V)
 Compute the (5,5)-Padé approximant to the exponential. More...
 
template<typename MatA , typename MatU , typename MatV >
void matrix_exp_pade7 (const MatA &A, MatU &U, MatV &V)
 Compute the (7,7)-Padé approximant to the exponential. More...
 
template<typename MatA , typename MatU , typename MatV >
void matrix_exp_pade9 (const MatA &A, MatU &U, MatV &V)
 Compute the (9,9)-Padé approximant to the exponential. More...
 
template<typename MatrixType , typename VectorType >
void matrix_function_compute_above_diagonal (const MatrixType &T, const VectorType &blockStart, const VectorType &clusterSize, MatrixType &fT)
 Compute part of matrix function above block diagonal. More...
 
template<typename MatrixType , typename AtomicType , typename VectorType >
void matrix_function_compute_block_atomic (const MatrixType &T, AtomicType &atomic, const VectorType &blockStart, const VectorType &clusterSize, MatrixType &fT)
 Compute block diagonal part of matrix function. More...
 
template<typename VectorType >
void matrix_function_compute_block_start (const VectorType &clusterSize, VectorType &blockStart)
 Compute start of each block using clusterSize. More...
 
template<typename ListOfClusters , typename Index >
void matrix_function_compute_cluster_size (const ListOfClusters &clusters, Matrix< Index, Dynamic, 1 > &clusterSize)
 Compute size of each cluster given a partitioning. More...
 
template<typename EivalsType , typename ListOfClusters , typename VectorType >
void matrix_function_compute_map (const EivalsType &eivals, const ListOfClusters &clusters, VectorType &eivalToCluster)
 Compute mapping of eigenvalue indices to cluster indices. More...
 
template<typename MatrixType >
NumTraits< typename MatrixType::Scalar >::Real matrix_function_compute_mu (const MatrixType &A)
 
template<typename DynVectorType , typename VectorType >
void matrix_function_compute_permutation (const DynVectorType &blockStart, const DynVectorType &eivalToCluster, VectorType &permutation)
 Compute permutation which groups ei'vals in same cluster together. More...
 
template<typename Index , typename ListOfClusters >
ListOfClusters::iterator matrix_function_find_cluster (Index key, ListOfClusters &clusters)
 Find cluster in clusters containing some value. More...
 
template<typename EivalsType , typename Cluster >
void matrix_function_partition_eigenvalues (const EivalsType &eivals, std::list< Cluster > &clusters)
 Partition eigenvalues in clusters of ei'vals close to each other. More...
 
template<typename VectorType , typename MatrixType >
void matrix_function_permute_schur (VectorType &permutation, MatrixType &U, MatrixType &T)
 Permute Schur decomposition in U and T according to permutation. More...
 
template<typename MatrixType >
MatrixType matrix_function_solve_triangular_sylvester (const MatrixType &A, const MatrixType &B, const MatrixType &C)
 Solve a triangular Sylvester equation AX + XB = C. More...
 
template<typename MatrixType >
void matrix_log_compute_2x2 (const MatrixType &A, MatrixType &result)
 Compute logarithm of 2x2 triangular matrix. More...
 
template<typename MatrixType >
void matrix_log_compute_big (const MatrixType &A, MatrixType &result)
 Compute logarithm of triangular matrices with size > 2. More...
 
template<typename MatrixType >
void matrix_log_compute_pade (MatrixType &result, const MatrixType &T, int degree)
 
int matrix_log_get_pade_degree (float normTminusI)
 
int matrix_log_get_pade_degree (double normTminusI)
 
int matrix_log_get_pade_degree (long double normTminusI)
 
template<typename MatrixType , typename ResultType >
void matrix_sqrt_quasi_triangular_1x1_off_diagonal_block (const MatrixType &T, Index i, Index j, ResultType &sqrtT)
 
template<typename MatrixType , typename ResultType >
void matrix_sqrt_quasi_triangular_1x2_off_diagonal_block (const MatrixType &T, Index i, Index j, ResultType &sqrtT)
 
template<typename MatrixType , typename ResultType >
void matrix_sqrt_quasi_triangular_2x1_off_diagonal_block (const MatrixType &T, Index i, Index j, ResultType &sqrtT)
 
template<typename MatrixType , typename ResultType >
void matrix_sqrt_quasi_triangular_2x2_diagonal_block (const MatrixType &T, Index i, ResultType &sqrtT)
 
template<typename MatrixType , typename ResultType >
void matrix_sqrt_quasi_triangular_2x2_off_diagonal_block (const MatrixType &T, Index i, Index j, ResultType &sqrtT)
 
template<typename MatrixType , typename ResultType >
void matrix_sqrt_quasi_triangular_diagonal (const MatrixType &T, ResultType &sqrtT)
 
template<typename MatrixType , typename ResultType >
void matrix_sqrt_quasi_triangular_off_diagonal (const MatrixType &T, ResultType &sqrtT)
 
template<typename MatrixType >
void matrix_sqrt_quasi_triangular_solve_auxiliary_equation (MatrixType &X, const MatrixType &A, const MatrixType &B, const MatrixType &C)
 
template<typename Scalar , typename Packet , typename Index , const Index accRows, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_ALWAYS_INLINE void MICRO_COMPLEX_EXTRA_COL (const Scalar *&lhs_ptr_real, const Scalar *&lhs_ptr_imag, const Scalar *&rhs_ptr_real, const Scalar *&rhs_ptr_imag, PacketBlock< Packet, 1 > &accReal, PacketBlock< Packet, 1 > &accImag, Index remaining_rows, Index remaining_cols)
 
template<typename Scalar , typename Packet , typename Index , const Index accRows, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_ALWAYS_INLINE void MICRO_COMPLEX_EXTRA_ROW (const Scalar *&lhs_ptr_real, const Scalar *&lhs_ptr_imag, const Scalar *&rhs_ptr_real, const Scalar *&rhs_ptr_imag, PacketBlock< Packet, 4 > &accReal, PacketBlock< Packet, 4 > &accImag, Index remaining_rows)
 
template<typename Scalar , typename Packet , typename Index >
EIGEN_ALWAYS_INLINE void MICRO_EXTRA_COL (const Scalar *&lhs_ptr, const Scalar *&rhs_ptr, PacketBlock< Packet, 1 > &accZero, Index remaining_rows, Index remaining_cols)
 
template<typename Scalar , typename Packet , typename Index , const Index accRows>
EIGEN_ALWAYS_INLINE void MICRO_EXTRA_ROW (const Scalar *&lhs_ptr, const Scalar *&rhs_ptr, PacketBlock< Packet, 4 > &accZero, Index remaining_rows)
 
template<typename BVH , typename Minimizer >
Minimizer::Scalar minimize_helper (const BVH &tree, Minimizer &minimizer, typename BVH::Index root, typename Minimizer::Scalar minimum)
 
template<typename Scalar , typename StorageIndex >
void minimum_degree_ordering (SparseMatrix< Scalar, ColMajor, StorageIndex > &C, PermutationMatrix< Dynamic, Dynamic, StorageIndex > &perm)
 
template<typename MatrixType , typename Rhs , typename Dest , typename Preconditioner >
EIGEN_DONT_INLINE void minres (const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, Index &iters, typename Dest::RealScalar &tol_error)
 
template<typename T >
T negate (const T &x)
 
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 Vector , typename RealScalar >
Vector::Scalar omega (const Vector &t, const Vector &s, RealScalar angle)
 
template<typename HL , typename LL , typename HR , typename LR >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool operator!= (const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
 
template<typename HL , typename LL , typename HR , typename LR >
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorUInt128< uint64_t, uint64_toperator* (const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
 
template<typename HL , typename LL , typename HR , typename LR >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE TensorUInt128< uint64_t, uint64_toperator+ (const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
 
template<typename HL , typename LL , typename HR , typename LR >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE TensorUInt128< uint64_t, uint64_toperator- (const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
 
template<typename HL , typename LL , typename HR , typename LR >
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorUInt128< uint64_t, uint64_toperator/ (const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
 
template<typename T , bool div_gt_one>
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator/ (const T &numerator, const TensorIntDivisor< T, div_gt_one > &divisor)
 
template<typename HL , typename LL , typename HR , typename LR >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool operator< (const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
 
std::ostream & operator<< (std::ostream &os, const Packet2cf &value)
 
std::ostream & operator<< (std::ostream &os, const PacketBlock< Packet2cf, 2 > &value)
 
std::ostream & operator<< (std::ostream &s, const Packet16c &v)
 
std::ostream & operator<< (std::ostream &s, const Packet16uc &v)
 
std::ostream & operator<< (std::ostream &s, const Packet4f &v)
 
std::ostream & operator<< (std::ostream &s, const Packet4i &v)
 
std::ostream & operator<< (std::ostream &os, const Packet1cd &value)
 
std::ostream & operator<< (std::ostream &s, const Packet4ui &v)
 
std::ostream & operator<< (std::ostream &os, const PacketBlock< Packet1cd, 2 > &value)
 
std::ostream & operator<< (std::ostream &os, const PacketBlock< Packet4f, 4 > &value)
 
std::ostream & operator<< (std::ostream &os, const PacketBlock< Packet4i, 4 > &value)
 
std::ostream & operator<< (std::ostream &os, const Packet2d &value)
 
std::ostream & operator<< (std::ostream &os, const Packet2l &value)
 
std::ostream & operator<< (std::ostream &os, const Packet2ul &value)
 
std::ostream & operator<< (std::ostream &os, const PacketBlock< Packet2d, 2 > &value)
 
template<typename HL , typename LL , typename HR , typename LR >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool operator== (const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
 
template<typename HL , typename LL , typename HR , typename LR >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool operator>= (const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
 
template<typename MatrixType >
void ordering_helper_at_plus_a (const MatrixType &A, MatrixType &symmat)
 
template<typename Dst , typename Lhs , typename Rhs , typename Func >
void EIGEN_DEVICE_FUNC outer_product_selector_run (Dst &dst, const Lhs &lhs, const Rhs &rhs, const Func &func, const false_type &)
 
template<typename Dst , typename Lhs , typename Rhs , typename Func >
void EIGEN_DEVICE_FUNC outer_product_selector_run (Dst &dst, const Lhs &lhs, const Rhs &rhs, const Func &func, const true_type &)
 
uint32x2_t p2ui_CONJ_XOR ()
 
uint32x4_t p4ui_CONJ_XOR ()
 
template<>
EIGEN_STRONG_INLINE PacketXi pabs (const PacketXi &a)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pabs (const Packet &a)
 
template<>
EIGEN_DEVICE_FUNC unsigned int pabs (const unsigned int &a)
 
template<>
EIGEN_DEVICE_FUNC unsigned long pabs (const unsigned long &a)
 
template<>
EIGEN_DEVICE_FUNC unsigned long long pabs (const unsigned long long &a)
 
template<>
EIGEN_STRONG_INLINE PacketXf pabs (const PacketXf &a)
 
template<>
EIGEN_STRONG_INLINE Packet8f pabs (const Packet8f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4d pabs (const Packet4d &a)
 
template<>
EIGEN_STRONG_INLINE Packet16f pabs (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8d pabs (const Packet8d &a)
 
template<>
EIGEN_STRONG_INLINE Packet8h pabs (const Packet8h &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d pabs (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f pabs (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i pabs (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet8s pabs (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE Packet8us pabs (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE Packet16c pabs (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pabs (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pabs (const Packet8bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet16h pabs (const Packet16h &a)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pabs (const Packet16bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet2f pabs (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8c pabs (const Packet8c &a)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pabs (const Packet4uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pabs (const Packet8uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet4s pabs (const Packet4s &a)
 
template<>
EIGEN_STRONG_INLINE Packet4us pabs (const Packet4us &a)
 
template<>
EIGEN_STRONG_INLINE Packet2i pabs (const Packet2i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pabs (const Packet2ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pabs (const Packet4ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet2l pabs (const Packet2l &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pabs (const Packet2ul &a)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pabs (const Packet4bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d pabs< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4c pabs< Packet4c > (const Packet4c &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f pabs< Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i pabs< Packet4i > (const Packet4i &a)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pabsdiff (const Packet &a, const Packet &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c pabsdiff< Packet16c > (const Packet16c &a, const Packet16c &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pabsdiff< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f pabsdiff< Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2i pabsdiff< Packet2i > (const Packet2i &a, const Packet2i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pabsdiff< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pabsdiff< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4c pabsdiff< Packet4c > (const Packet4c &a, const Packet4c &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f pabsdiff< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i pabsdiff< Packet4i > (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet4s pabsdiff< Packet4s > (const Packet4s &a, const Packet4s &b)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pabsdiff< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pabsdiff< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet4us pabsdiff< Packet4us > (const Packet4us &a, const Packet4us &b)
 
template<>
EIGEN_STRONG_INLINE Packet8c pabsdiff< Packet8c > (const Packet8c &a, const Packet8c &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s pabsdiff< Packet8s > (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pabsdiff< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us pabsdiff< Packet8us > (const Packet8us &a, const Packet8us &b)
 
EIGEN_STRONG_INLINE __m128i Pack16To8 (Packet8f rf)
 
EIGEN_STRONG_INLINE __m256i Pack32To16 (Packet16f rf)
 
template<typename PacketType , typename Func >
EIGEN_DEVICE_FUNC PacketType packetwise_redux_empty_value (const Func &)
 
template<typename PacketType , typename Scalar >
EIGEN_DEVICE_FUNC PacketType packetwise_redux_empty_value (const scalar_product_op< Scalar, Scalar > &)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pacos (const Packet &a)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet padd (const Packet &a, const Packet &b)
 
template<>
EIGEN_DEVICE_FUNC bool padd (const bool &a, const bool &b)
 
template<typename Packet >
DoublePacket< Packetpadd (const DoublePacket< Packet > &a, const DoublePacket< Packet > &b)
 
template<>
EIGEN_STRONG_INLINE Packet16b padd< Packet16b > (const Packet16b &a, const Packet16b &b)
 
template<>
EIGEN_STRONG_INLINE Packet16bf padd< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c padd< Packet16c > (const Packet16c &a, const Packet16c &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f padd< Packet16f > (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet16h padd< Packet16h > (const Packet16h &a, const Packet16h &b)
 
template<>
EIGEN_STRONG_INLINE Packet16i padd< Packet16i > (const Packet16i &a, const Packet16i &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc padd< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet1cd padd< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet1cf padd< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cd padd< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cf padd< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d padd< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f padd< Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2i padd< Packet2i > (const Packet2i &a, const Packet2i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2l padd< Packet2l > (const Packet2l &a, const Packet2l &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ui padd< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ul padd< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf padd< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4c padd< Packet4c > (const Packet4c &a, const Packet4c &b)
 
template<>
EIGEN_STRONG_INLINE Packet4cd padd< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet4cf padd< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d padd< Packet4d > (const Packet4d &a, const Packet4d &b)
 
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 Packet4s padd< Packet4s > (const Packet4s &a, const Packet4s &b)
 
template<>
EIGEN_STRONG_INLINE Packet4uc padd< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet4ui padd< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet4us padd< Packet4us > (const Packet4us &a, const Packet4us &b)
 
template<>
EIGEN_STRONG_INLINE Packet8bf padd< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8c padd< Packet8c > (const Packet8c &a, const Packet8c &b)
 
template<>
EIGEN_STRONG_INLINE Packet8cf padd< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d padd< Packet8d > (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f padd< Packet8f > (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8h padd< Packet8h > (const Packet8h &a, const Packet8h &b)
 
template<>
EIGEN_STRONG_INLINE Packet8i padd< Packet8i > (const Packet8i &a, const Packet8i &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s padd< Packet8s > (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet8uc padd< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us padd< Packet8us > (const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_STRONG_INLINE PacketXf padd< PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<>
EIGEN_STRONG_INLINE PacketXi padd< PacketXi > (const PacketXi &a, const PacketXi &b)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet paddsub (const Packet &a, const Packet &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d paddsub< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f paddsub< Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f paddsub< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pand (const Packet &a, const Packet &b)
 
template<>
EIGEN_STRONG_INLINE Packet8h pand (const Packet8h &a, const Packet8h &b)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pand (const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16h pand (const Packet16h &a, const Packet16h &b)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pand (const Packet16bf &a, const Packet16bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pand (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16b pand< Packet16b > (const Packet16b &a, const Packet16b &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c pand< Packet16c > (const Packet16c &a, const Packet16c &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f pand< Packet16f > (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet16i pand< Packet16i > (const Packet16i &a, const Packet16i &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pand< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet1cd pand< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet1cf pand< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cd pand< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cf pand< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d pand< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f pand< Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2i pand< Packet2i > (const Packet2i &a, const Packet2i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2l pand< Packet2l > (const Packet2l &a, const Packet2l &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pand< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pand< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
 
template<>
EIGEN_STRONG_INLINE Packet4c pand< Packet4c > (const Packet4c &a, const Packet4c &b)
 
template<>
EIGEN_STRONG_INLINE Packet4cd pand< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet4cf pand< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d pand< Packet4d > (const Packet4d &a, const Packet4d &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 Packet4s pand< Packet4s > (const Packet4s &a, const Packet4s &b)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pand< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pand< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet4us pand< Packet4us > (const Packet4us &a, const Packet4us &b)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pand< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8c pand< Packet8c > (const Packet8c &a, const Packet8c &b)
 
template<>
EIGEN_STRONG_INLINE Packet8cf pand< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d pand< Packet8d > (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f pand< Packet8f > (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8i pand< Packet8i > (const Packet8i &a, const Packet8i &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s pand< Packet8s > (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pand< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us pand< Packet8us > (const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_STRONG_INLINE PacketXf pand< PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<>
EIGEN_STRONG_INLINE PacketXi pand< PacketXi > (const PacketXi &a, const PacketXi &b)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pandnot (const Packet &a, const Packet &b)
 
template<>
EIGEN_STRONG_INLINE Packet8h pandnot (const Packet8h &a, const Packet8h &b)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pandnot (const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16h pandnot (const Packet16h &a, const Packet16h &b)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pandnot (const Packet16bf &a, const Packet16bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pandnot (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c pandnot< Packet16c > (const Packet16c &a, const Packet16c &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f pandnot< Packet16f > (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet16i pandnot< Packet16i > (const Packet16i &a, const Packet16i &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pandnot< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet1cd pandnot< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet1cf pandnot< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cd pandnot< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cf pandnot< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d pandnot< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f pandnot< Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2i pandnot< Packet2i > (const Packet2i &a, const Packet2i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2l pandnot< Packet2l > (const Packet2l &a, const Packet2l &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pandnot< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pandnot< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
 
template<>
EIGEN_STRONG_INLINE Packet4c pandnot< Packet4c > (const Packet4c &a, const Packet4c &b)
 
template<>
EIGEN_STRONG_INLINE Packet4cd pandnot< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet4cf pandnot< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d pandnot< Packet4d > (const Packet4d &a, const Packet4d &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 Packet4s pandnot< Packet4s > (const Packet4s &a, const Packet4s &b)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pandnot< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pandnot< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet4us pandnot< Packet4us > (const Packet4us &a, const Packet4us &b)
 
template<>
EIGEN_STRONG_INLINE Packet8c pandnot< Packet8c > (const Packet8c &a, const Packet8c &b)
 
template<>
EIGEN_STRONG_INLINE Packet8cf pandnot< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d pandnot< Packet8d > (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f pandnot< Packet8f > (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8i pandnot< Packet8i > (const Packet8i &a, const Packet8i &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s pandnot< Packet8s > (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pandnot< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us pandnot< Packet8us > (const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_STRONG_INLINE PacketXf pandnot< PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<>
EIGEN_STRONG_INLINE PacketXi pandnot< PacketXi > (const PacketXi &a, const PacketXi &b)
 
template<bool Condition, typename Functor , typename Index >
void parallelize_gemm (const Functor &func, Index rows, Index cols, Index depth, bool transpose)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet parg (const Packet &a)
 
template<int N>
EIGEN_STRONG_INLINE PacketXi parithmetic_shift_right (PacketXi a)
 
template<int N>
EIGEN_STRONG_INLINE Packet8i parithmetic_shift_right (Packet8i a)
 
template<int N>
EIGEN_DEVICE_FUNC int parithmetic_shift_right (const int &a)
 
template<int N>
EIGEN_DEVICE_FUNC long int parithmetic_shift_right (const long int &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet16i parithmetic_shift_right (Packet16i a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4i parithmetic_shift_right (const Packet4i &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4c parithmetic_shift_right (Packet4c &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet8c parithmetic_shift_right (Packet8c a)
 
template<int N>
EIGEN_STRONG_INLINE Packet16c parithmetic_shift_right (Packet16c a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4uc parithmetic_shift_right (Packet4uc &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet8uc parithmetic_shift_right (Packet8uc a)
 
template<int N>
EIGEN_STRONG_INLINE Packet16uc parithmetic_shift_right (Packet16uc a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4s parithmetic_shift_right (Packet4s a)
 
template<int N>
EIGEN_STRONG_INLINE Packet8s parithmetic_shift_right (Packet8s a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4us parithmetic_shift_right (Packet4us a)
 
template<int N>
EIGEN_STRONG_INLINE Packet8us parithmetic_shift_right (Packet8us a)
 
template<int N>
EIGEN_STRONG_INLINE Packet2i parithmetic_shift_right (Packet2i a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4i parithmetic_shift_right (Packet4i a)
 
template<int N>
EIGEN_STRONG_INLINE Packet2ui parithmetic_shift_right (Packet2ui a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4ui parithmetic_shift_right (Packet4ui a)
 
template<int N>
EIGEN_STRONG_INLINE Packet2l parithmetic_shift_right (Packet2l a)
 
template<int N>
EIGEN_STRONG_INLINE Packet2ul parithmetic_shift_right (Packet2ul a)
 
template<typename MatrixType , typename TranspositionType >
void partial_lu_inplace (MatrixType &lu, TranspositionType &row_transpositions, typename TranspositionType::StorageIndex &nb_transpositions)
 
template<typename Packet >
static Packet pasin (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 patan (const Packet &a)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_i0 (const Packet &x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_i0e (const Packet &x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_i1 (const Packet &x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_i1e (const Packet &x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_j0 (const Packet &x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_j1 (const Packet &x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_k0 (const Packet &x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_k0e (const Packet &x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_k1 (const Packet &x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_k1e (const Packet &x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_y0 (const Packet &x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_y1 (const Packet &x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pbetainc (const Packet &a, const Packet &b, const Packet &x)
 
template<>
EIGEN_STRONG_INLINE Packet2cf pblend (const Selector< 2 > &ifPacket, const Packet2cf &thenPacket, const Packet2cf &elsePacket)
 
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<typename Packet >
EIGEN_DEVICE_FUNC Packet pblend (const Selector< unpacket_traits< Packet >::size > &ifPacket, const Packet &thenPacket, const Packet &elsePacket)
 
template<>
EIGEN_STRONG_INLINE Packet2d pblend (const Selector< 2 > &ifPacket, const Packet2d &thenPacket, const Packet2d &elsePacket)
 
template<>
EIGEN_STRONG_INLINE Packet16f pblend (const Selector< 16 > &, const Packet16f &, const Packet16f &)
 
template<>
EIGEN_STRONG_INLINE Packet8d pblend (const Selector< 8 > &ifPacket, const Packet8d &thenPacket, const Packet8d &elsePacket)
 
template<>
EIGEN_STRONG_INLINE Packet4i pblend (const Selector< 4 > &ifPacket, const Packet4i &thenPacket, const Packet4i &elsePacket)
 
template<>
EIGEN_STRONG_INLINE Packet4f pblend (const Selector< 4 > &ifPacket, const Packet4f &thenPacket, const Packet4f &elsePacket)
 
template<>
EIGEN_STRONG_INLINE Packet8s pblend (const Selector< 8 > &ifPacket, const Packet8s &thenPacket, const Packet8s &elsePacket)
 
template<>
EIGEN_STRONG_INLINE Packet8us pblend (const Selector< 8 > &ifPacket, const Packet8us &thenPacket, const Packet8us &elsePacket)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pblend (const Selector< 8 > &ifPacket, const Packet8bf &thenPacket, const Packet8bf &elsePacket)
 
template<>
EIGEN_STRONG_INLINE Packet16c pblend (const Selector< 16 > &ifPacket, const Packet16c &thenPacket, const Packet16c &elsePacket)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pblend (const Selector< 16 > &ifPacket, const Packet16uc &thenPacket, const Packet16uc &elsePacket)
 
template<typename Packet >
EIGEN_STRONG_INLINE Packet pblend4 (const Selector< 4 > &ifPacket, const Packet &thenPacket, const Packet &elsePacket)
 
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 void pbroadcast4 (const typename unpacket_traits< Packet >::type *a, Packet &a0, Packet &a1, Packet &a2, Packet &a3)
 
template<>
EIGEN_STRONG_INLINE void pbroadcast4< Packet2d > (const double *a, Packet2d &a0, Packet2d &a1, Packet2d &a2, Packet2d &a3)
 
template<>
EIGEN_STRONG_INLINE void pbroadcast4< Packet4f > (const float *a, Packet4f &a0, Packet4f &a1, Packet4f &a2, Packet4f &a3)
 
template<>
EIGEN_STRONG_INLINE void pbroadcast4< Packet4i > (const int *a, Packet4i &a0, Packet4i &a1, Packet4i &a2, Packet4i &a3)
 
template<typename Packet >
EIGEN_STRONG_INLINE void pbroadcast4_common (const __UNPACK_TYPE__(Packet) *a, Packet &a0, Packet &a1, Packet &a2, Packet &a3)
 
template<typename Packet >
EIGEN_ALWAYS_INLINE void pbroadcast4_old (const __UNPACK_TYPE__(Packet) *a, Packet &a0, Packet &a1, Packet &a2, Packet &a3)
 
template<>
EIGEN_ALWAYS_INLINE void pbroadcast4_old< Packet2d > (const double *a, Packet2d &a0, Packet2d &a1, Packet2d &a2, Packet2d &a3)
 
template<typename SrcPacket , typename TgtPacket >
EIGEN_DEVICE_FUNC TgtPacket pcast (const SrcPacket &a)
 
template<typename SrcPacket , typename TgtPacket >
EIGEN_DEVICE_FUNC TgtPacket pcast (const SrcPacket &a, const SrcPacket &)
 
template<typename SrcPacket , typename TgtPacket >
EIGEN_DEVICE_FUNC TgtPacket pcast (const SrcPacket &a, const SrcPacket &, const SrcPacket &, const SrcPacket &)
 
template<typename SrcPacket , typename TgtPacket >
EIGEN_DEVICE_FUNC TgtPacket pcast (const SrcPacket &a, const SrcPacket &, const SrcPacket &, const SrcPacket &, const SrcPacket &, const SrcPacket &, const SrcPacket &, const SrcPacket &)
 
template<>
EIGEN_STRONG_INLINE Packet1cf pcast< float, Packet1cf > (const float &a)
 
template<>
EIGEN_STRONG_INLINE Packet16f pcast< Packet16bf, Packet16f > (const Packet16bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet16c pcast< Packet16c, Packet16c > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pcast< Packet16c, Packet16uc > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE Packet2l pcast< Packet16c, Packet2l > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pcast< Packet16c, Packet2ul > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcast< Packet16c, Packet4f > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i pcast< Packet16c, Packet4i > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pcast< Packet16c, Packet4ui > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE Packet8s pcast< Packet16c, Packet8s > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE Packet8us pcast< Packet16c, Packet8us > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pcast< Packet16f, Packet16bf > (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE Packet16h pcast< Packet16f, Packet16h > (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE Packet16i pcast< Packet16f, Packet16i > (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE Packet16f pcast< Packet16h, Packet16f > (const Packet16h &a)
 
template<>
EIGEN_STRONG_INLINE Packet16f pcast< Packet16i, Packet16f > (const Packet16i &a)
 
template<>
EIGEN_STRONG_INLINE Packet16c pcast< Packet16uc, Packet16c > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pcast< Packet16uc, Packet16uc > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet2l pcast< Packet16uc, Packet2l > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pcast< Packet16uc, Packet2ul > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcast< Packet16uc, Packet4f > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i pcast< Packet16uc, Packet4i > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pcast< Packet16uc, Packet4ui > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet8s pcast< Packet16uc, Packet8s > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet8us pcast< Packet16uc, Packet8us > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcast< Packet2d, Packet4f > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cf pcast< Packet2f, Packet2cf > (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE Packet2f pcast< Packet2f, Packet2f > (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE Packet2i pcast< Packet2f, Packet2i > (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pcast< Packet2f, Packet2ui > (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4s pcast< Packet2f, Packet4s > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4us pcast< Packet2f, Packet4us > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8c pcast< Packet2f, Packet8c > (const Packet2f &a, const Packet2f &b, const Packet2f &c, const Packet2f &d)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pcast< Packet2f, Packet8uc > (const Packet2f &a, const Packet2f &b, const Packet2f &c, const Packet2f &d)
 
template<>
EIGEN_STRONG_INLINE Packet2f pcast< Packet2i, Packet2f > (const Packet2i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2i pcast< Packet2i, Packet2i > (const Packet2i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pcast< Packet2i, Packet2ui > (const Packet2i &a)
 
template<>
EIGEN_STRONG_INLINE Packet4s pcast< Packet2i, Packet4s > (const Packet2i &a, const Packet2i &b)
 
template<>
EIGEN_STRONG_INLINE Packet4us pcast< Packet2i, Packet4us > (const Packet2i &a, const Packet2i &b)
 
template<>
EIGEN_STRONG_INLINE Packet8c pcast< Packet2i, Packet8c > (const Packet2i &a, const Packet2i &b, const Packet2i &c, const Packet2i &d)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pcast< Packet2i, Packet8uc > (const Packet2i &a, const Packet2i &b, const Packet2i &c, const Packet2i &d)
 
template<>
EIGEN_STRONG_INLINE Packet16c pcast< Packet2l, Packet16c > (const Packet2l &a, const Packet2l &b, const Packet2l &c, const Packet2l &d, const Packet2l &e, const Packet2l &f, const Packet2l &g, const Packet2l &h)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pcast< Packet2l, Packet16uc > (const Packet2l &a, const Packet2l &b, const Packet2l &c, const Packet2l &d, const Packet2l &e, const Packet2l &f, const Packet2l &g, const Packet2l &h)
 
template<>
EIGEN_STRONG_INLINE Packet2l pcast< Packet2l, Packet2l > (const Packet2l &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pcast< Packet2l, Packet2ul > (const Packet2l &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcast< Packet2l, Packet4f > (const Packet2l &a, const Packet2l &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i pcast< Packet2l, Packet4i > (const Packet2l &a, const Packet2l &b)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pcast< Packet2l, Packet4ui > (const Packet2l &a, const Packet2l &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s pcast< Packet2l, Packet8s > (const Packet2l &a, const Packet2l &b, const Packet2l &c, const Packet2l &d)
 
template<>
EIGEN_STRONG_INLINE Packet8us pcast< Packet2l, Packet8us > (const Packet2l &a, const Packet2l &b, const Packet2l &c, const Packet2l &d)
 
template<>
EIGEN_STRONG_INLINE Packet2f pcast< Packet2ui, Packet2f > (const Packet2ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet2i pcast< Packet2ui, Packet2i > (const Packet2ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pcast< Packet2ui, Packet2ui > (const Packet2ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet4s pcast< Packet2ui, Packet4s > (const Packet2ui &a, const Packet2ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet4us pcast< Packet2ui, Packet4us > (const Packet2ui &a, const Packet2ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet8c pcast< Packet2ui, Packet8c > (const Packet2ui &a, const Packet2ui &b, const Packet2ui &c, const Packet2ui &d)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pcast< Packet2ui, Packet8uc > (const Packet2ui &a, const Packet2ui &b, const Packet2ui &c, const Packet2ui &d)
 
template<>
EIGEN_STRONG_INLINE Packet16c pcast< Packet2ul, Packet16c > (const Packet2ul &a, const Packet2ul &b, const Packet2ul &c, const Packet2ul &d, const Packet2ul &e, const Packet2ul &f, const Packet2ul &g, const Packet2ul &h)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pcast< Packet2ul, Packet16uc > (const Packet2ul &a, const Packet2ul &b, const Packet2ul &c, const Packet2ul &d, const Packet2ul &e, const Packet2ul &f, const Packet2ul &g, const Packet2ul &h)
 
template<>
EIGEN_STRONG_INLINE Packet2l pcast< Packet2ul, Packet2l > (const Packet2ul &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pcast< Packet2ul, Packet2ul > (const Packet2ul &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcast< Packet2ul, Packet4f > (const Packet2ul &a, const Packet2ul &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i pcast< Packet2ul, Packet4i > (const Packet2ul &a, const Packet2ul &b)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pcast< Packet2ul, Packet4ui > (const Packet2ul &a, const Packet2ul &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s pcast< Packet2ul, Packet8s > (const Packet2ul &a, const Packet2ul &b, const Packet2ul &c, const Packet2ul &d)
 
template<>
EIGEN_STRONG_INLINE Packet8us pcast< Packet2ul, Packet8us > (const Packet2ul &a, const Packet2ul &b, const Packet2ul &c, const Packet2ul &d)
 
template<>
EIGEN_STRONG_INLINE Packet4c pcast< Packet4c, Packet4c > (const Packet4c &a)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pcast< Packet4c, Packet4uc > (const Packet4c &a)
 
template<>
EIGEN_STRONG_INLINE Packet16c pcast< Packet4f, Packet16c > (const Packet4f &a, const Packet4f &b, const Packet4f &c, const Packet4f &d)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pcast< Packet4f, Packet16uc > (const Packet4f &a, const Packet4f &b, const Packet4f &c, const Packet4f &d)
 
template<>
EIGEN_STRONG_INLINE Packet2d pcast< Packet4f, Packet2d > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet2l pcast< Packet4f, Packet2l > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pcast< Packet4f, Packet2ul > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcast< Packet4f, Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i pcast< Packet4f, Packet4i > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pcast< Packet4f, Packet4ui > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8s pcast< Packet4f, Packet8s > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us pcast< Packet4f, Packet8us > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c pcast< Packet4i, Packet16c > (const Packet4i &a, const Packet4i &b, const Packet4i &c, const Packet4i &d)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pcast< Packet4i, Packet16uc > (const Packet4i &a, const Packet4i &b, const Packet4i &c, const Packet4i &d)
 
template<>
EIGEN_STRONG_INLINE Packet2l pcast< Packet4i, Packet2l > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pcast< Packet4i, Packet2ul > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcast< Packet4i, Packet4f > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i pcast< Packet4i, Packet4i > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pcast< Packet4i, Packet4ui > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet8s pcast< Packet4i, Packet8s > (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us pcast< Packet4i, Packet8us > (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f pcast< Packet4s, Packet2f > (const Packet4s &a)
 
template<>
EIGEN_STRONG_INLINE Packet2i pcast< Packet4s, Packet2i > (const Packet4s &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pcast< Packet4s, Packet2ui > (const Packet4s &a)
 
template<>
EIGEN_STRONG_INLINE Packet4s pcast< Packet4s, Packet4s > (const Packet4s &a)
 
template<>
EIGEN_STRONG_INLINE Packet4us pcast< Packet4s, Packet4us > (const Packet4s &a)
 
template<>
EIGEN_STRONG_INLINE Packet8c pcast< Packet4s, Packet8c > (const Packet4s &a, const Packet4s &b)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pcast< Packet4s, Packet8uc > (const Packet4s &a, const Packet4s &b)
 
template<>
EIGEN_STRONG_INLINE Packet4c pcast< Packet4uc, Packet4c > (const Packet4uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pcast< Packet4uc, Packet4uc > (const Packet4uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet16c pcast< Packet4ui, Packet16c > (const Packet4ui &a, const Packet4ui &b, const Packet4ui &c, const Packet4ui &d)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pcast< Packet4ui, Packet16uc > (const Packet4ui &a, const Packet4ui &b, const Packet4ui &c, const Packet4ui &d)
 
template<>
EIGEN_STRONG_INLINE Packet2l pcast< Packet4ui, Packet2l > (const Packet4ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pcast< Packet4ui, Packet2ul > (const Packet4ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcast< Packet4ui, Packet4f > (const Packet4ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i pcast< Packet4ui, Packet4i > (const Packet4ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pcast< Packet4ui, Packet4ui > (const Packet4ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet8s pcast< Packet4ui, Packet8s > (const Packet4ui &a, const Packet4ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us pcast< Packet4ui, Packet8us > (const Packet4ui &a, const Packet4ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f pcast< Packet4us, Packet2f > (const Packet4us &a)
 
template<>
EIGEN_STRONG_INLINE Packet2i pcast< Packet4us, Packet2i > (const Packet4us &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pcast< Packet4us, Packet2ui > (const Packet4us &a)
 
template<>
EIGEN_STRONG_INLINE Packet4s pcast< Packet4us, Packet4s > (const Packet4us &a)
 
template<>
EIGEN_STRONG_INLINE Packet4us pcast< Packet4us, Packet4us > (const Packet4us &a)
 
template<>
EIGEN_STRONG_INLINE Packet8c pcast< Packet4us, Packet8c > (const Packet4us &a, const Packet4us &b)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pcast< Packet4us, Packet8uc > (const Packet4us &a, const Packet4us &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f pcast< Packet8bf, Packet8f > (const Packet8bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet8us pcast< Packet8bf, Packet8us > (const Packet8bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet2f pcast< Packet8c, Packet2f > (const Packet8c &a)
 
template<>
EIGEN_STRONG_INLINE Packet2i pcast< Packet8c, Packet2i > (const Packet8c &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pcast< Packet8c, Packet2ui > (const Packet8c &a)
 
template<>
EIGEN_STRONG_INLINE Packet4s pcast< Packet8c, Packet4s > (const Packet8c &a)
 
template<>
EIGEN_STRONG_INLINE Packet4us pcast< Packet8c, Packet4us > (const Packet8c &a)
 
template<>
EIGEN_STRONG_INLINE Packet8c pcast< Packet8c, Packet8c > (const Packet8c &a)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pcast< Packet8c, Packet8uc > (const Packet8c &a)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pcast< Packet8f, Packet8bf > (const Packet8f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8h pcast< Packet8f, Packet8h > (const Packet8f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8i pcast< Packet8f, Packet8i > (const Packet8f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8f pcast< Packet8h, Packet8f > (const Packet8h &a)
 
template<>
EIGEN_STRONG_INLINE Packet8f pcast< Packet8i, Packet8f > (const Packet8i &a)
 
template<>
EIGEN_STRONG_INLINE Packet16c pcast< Packet8s, Packet16c > (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pcast< Packet8s, Packet16uc > (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet2l pcast< Packet8s, Packet2l > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pcast< Packet8s, Packet2ul > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcast< Packet8s, Packet4f > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i pcast< Packet8s, Packet4i > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pcast< Packet8s, Packet4ui > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE Packet8s pcast< Packet8s, Packet8s > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE Packet8us pcast< Packet8s, Packet8us > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE Packet2f pcast< Packet8uc, Packet2f > (const Packet8uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet2i pcast< Packet8uc, Packet2i > (const Packet8uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pcast< Packet8uc, Packet2ui > (const Packet8uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet4s pcast< Packet8uc, Packet4s > (const Packet8uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet4us pcast< Packet8uc, Packet4us > (const Packet8uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet8c pcast< Packet8uc, Packet8c > (const Packet8uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pcast< Packet8uc, Packet8uc > (const Packet8uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet16c pcast< Packet8us, Packet16c > (const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pcast< Packet8us, Packet16uc > (const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_STRONG_INLINE Packet2l pcast< Packet8us, Packet2l > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pcast< Packet8us, Packet2ul > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcast< Packet8us, Packet4f > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i pcast< Packet8us, Packet4i > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pcast< Packet8us, Packet4ui > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pcast< Packet8us, Packet8bf > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE Packet8s pcast< Packet8us, Packet8s > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE Packet8us pcast< Packet8us, Packet8us > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE PacketXi pcast< PacketXf, PacketXi > (const PacketXf &a)
 
template<>
EIGEN_STRONG_INLINE PacketXf pcast< PacketXi, PacketXf > (const PacketXi &a)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pceil (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pceil< Packet16bf > (const Packet16bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet16f pceil< Packet16f > (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE Packet16h pceil< Packet16h > (const Packet16h &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d pceil< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet2f pceil< Packet2f > (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pceil< Packet4bf > (const Packet4bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet4d pceil< Packet4d > (const Packet4d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f pceil< Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pceil< Packet8bf > (const Packet8bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet8d pceil< Packet8d > (const Packet8d &a)
 
template<>
EIGEN_STRONG_INLINE Packet8f pceil< Packet8f > (const Packet8f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8h pceil< Packet8h > (const Packet8h &a)
 
template<>
EIGEN_STRONG_INLINE Packet4cf pcmp_eq (const Packet4cf &a, const Packet4cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8cf pcmp_eq (const Packet8cf &a, const Packet8cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet1cf pcmp_eq (const Packet1cf &a, const Packet1cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cf pcmp_eq (const Packet2cf &a, const Packet2cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4cd pcmp_eq (const Packet4cd &a, const Packet4cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cd pcmp_eq (const Packet2cd &a, const Packet2cd &b)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pcmp_eq (const Packet &a, const Packet &b)
 
template<>
EIGEN_STRONG_INLINE Packet1cd pcmp_eq (const Packet1cd &a, const Packet1cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f pcmp_eq (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d pcmp_eq (const Packet4d &a, const Packet4d &b)
 
template<>
EIGEN_STRONG_INLINE Packet8i pcmp_eq (const Packet8i &a, const Packet8i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d pcmp_eq (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet16b pcmp_eq (const Packet16b &a, const Packet16b &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f pcmp_eq (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet16i pcmp_eq (const Packet16i &a, const Packet16i &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d pcmp_eq (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcmp_eq (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i pcmp_eq (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s pcmp_eq (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us pcmp_eq (const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c pcmp_eq (const Packet16c &a, const Packet16c &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pcmp_eq (const Packet16uc &a, const Packet16uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet8h pcmp_eq (const Packet8h &a, const Packet8h &b)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pcmp_eq (const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16h pcmp_eq (const Packet16h &a, const Packet16h &b)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pcmp_eq (const Packet16bf &a, const Packet16bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c pcmp_eq< Packet16c > (const Packet16c &a, const Packet16c &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pcmp_eq< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f pcmp_eq< Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2i pcmp_eq< Packet2i > (const Packet2i &a, const Packet2i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2l pcmp_eq< Packet2l > (const Packet2l &a, const Packet2l &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pcmp_eq< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pcmp_eq< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pcmp_eq< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4c pcmp_eq< Packet4c > (const Packet4c &a, const Packet4c &b)
 
template<>
Packet4f EIGEN_STRONG_INLINE pcmp_eq< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcmp_eq< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i pcmp_eq< Packet4i > (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet4s pcmp_eq< Packet4s > (const Packet4s &a, const Packet4s &b)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pcmp_eq< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pcmp_eq< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet4us pcmp_eq< Packet4us > (const Packet4us &a, const Packet4us &b)
 
template<>
EIGEN_STRONG_INLINE Packet8c pcmp_eq< Packet8c > (const Packet8c &a, const Packet8c &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s pcmp_eq< Packet8s > (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pcmp_eq< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us pcmp_eq< Packet8us > (const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_STRONG_INLINE PacketXf pcmp_eq< PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<>
EIGEN_STRONG_INLINE PacketXi pcmp_eq< PacketXi > (const PacketXi &a, const PacketXi &b)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pcmp_le (const Packet &a, const Packet &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f pcmp_le (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d pcmp_le (const Packet4d &a, const Packet4d &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d pcmp_le (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f pcmp_le (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d pcmp_le (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcmp_le (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i pcmp_le (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s pcmp_le (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us pcmp_le (const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c pcmp_le (const Packet16c &a, const Packet16c &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pcmp_le (const Packet16uc &a, const Packet16uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet8h pcmp_le (const Packet8h &a, const Packet8h &b)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pcmp_le (const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16h pcmp_le (const Packet16h &a, const Packet16h &b)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pcmp_le (const Packet16bf &a, const Packet16bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c pcmp_le< Packet16c > (const Packet16c &a, const Packet16c &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pcmp_le< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f pcmp_le< Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2i pcmp_le< Packet2i > (const Packet2i &a, const Packet2i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2l pcmp_le< Packet2l > (const Packet2l &a, const Packet2l &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pcmp_le< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pcmp_le< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pcmp_le< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4c pcmp_le< Packet4c > (const Packet4c &a, const Packet4c &b)
 
template<>
Packet4f EIGEN_STRONG_INLINE pcmp_le< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcmp_le< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i pcmp_le< Packet4i > (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet4s pcmp_le< Packet4s > (const Packet4s &a, const Packet4s &b)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pcmp_le< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pcmp_le< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet4us pcmp_le< Packet4us > (const Packet4us &a, const Packet4us &b)
 
template<>
EIGEN_STRONG_INLINE Packet8c pcmp_le< Packet8c > (const Packet8c &a, const Packet8c &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s pcmp_le< Packet8s > (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pcmp_le< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us pcmp_le< Packet8us > (const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_STRONG_INLINE PacketXf pcmp_le< PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<>
EIGEN_STRONG_INLINE PacketXi pcmp_le< PacketXi > (const PacketXi &a, const PacketXi &b)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pcmp_lt (const Packet &a, const Packet &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f pcmp_lt (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d pcmp_lt (const Packet4d &a, const Packet4d &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d pcmp_lt (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f pcmp_lt (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d pcmp_lt (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcmp_lt (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i pcmp_lt (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s pcmp_lt (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us pcmp_lt (const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c pcmp_lt (const Packet16c &a, const Packet16c &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pcmp_lt (const Packet16uc &a, const Packet16uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet8h pcmp_lt (const Packet8h &a, const Packet8h &b)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pcmp_lt (const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16h pcmp_lt (const Packet16h &a, const Packet16h &b)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pcmp_lt (const Packet16bf &a, const Packet16bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c pcmp_lt< Packet16c > (const Packet16c &a, const Packet16c &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pcmp_lt< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f pcmp_lt< Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2i pcmp_lt< Packet2i > (const Packet2i &a, const Packet2i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2l pcmp_lt< Packet2l > (const Packet2l &a, const Packet2l &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pcmp_lt< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pcmp_lt< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pcmp_lt< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4c pcmp_lt< Packet4c > (const Packet4c &a, const Packet4c &b)
 
template<>
Packet4f EIGEN_STRONG_INLINE pcmp_lt< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcmp_lt< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i pcmp_lt< Packet4i > (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet4s pcmp_lt< Packet4s > (const Packet4s &a, const Packet4s &b)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pcmp_lt< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pcmp_lt< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet4us pcmp_lt< Packet4us > (const Packet4us &a, const Packet4us &b)
 
template<>
EIGEN_STRONG_INLINE Packet8c pcmp_lt< Packet8c > (const Packet8c &a, const Packet8c &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s pcmp_lt< Packet8s > (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pcmp_lt< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us pcmp_lt< Packet8us > (const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_STRONG_INLINE PacketXf pcmp_lt< PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<>
EIGEN_STRONG_INLINE PacketXi pcmp_lt< PacketXi > (const PacketXi &a, const PacketXi &b)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pcmp_lt_or_nan (const Packet &a, const Packet &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f pcmp_lt_or_nan (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d pcmp_lt_or_nan (const Packet4d &a, const Packet4d &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d pcmp_lt_or_nan (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f pcmp_lt_or_nan (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d pcmp_lt_or_nan (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcmp_lt_or_nan (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8h pcmp_lt_or_nan (const Packet8h &a, const Packet8h &b)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pcmp_lt_or_nan (const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16h pcmp_lt_or_nan (const Packet16h &a, const Packet16h &b)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pcmp_lt_or_nan (const Packet16bf &a, const Packet16bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f pcmp_lt_or_nan< Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pcmp_lt_or_nan< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f pcmp_lt_or_nan< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE PacketXf pcmp_lt_or_nan< PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8cf pconj (const Packet8cf &a)
 
template<>
EIGEN_STRONG_INLINE Packet4cf pconj (const Packet4cf &a)
 
template<>
EIGEN_STRONG_INLINE PacketXi pconj (const PacketXi &a)
 
template<>
EIGEN_STRONG_INLINE Packet1cf pconj (const Packet1cf &a)
 
template<>
EIGEN_STRONG_INLINE Packet2cf pconj (const Packet2cf &a)
 
template<>
EIGEN_STRONG_INLINE Packet4cd pconj (const Packet4cd &a)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pconj (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE Packet2cd pconj (const Packet2cd &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 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 PacketXf pconj (const PacketXf &a)
 
template<>
EIGEN_STRONG_INLINE Packet1cd pconj (const Packet1cd &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f pconj (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i pconj (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2f pconj (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4c pconj (const Packet4c &a)
 
template<>
EIGEN_STRONG_INLINE Packet8c pconj (const Packet8c &a)
 
template<>
EIGEN_STRONG_INLINE Packet16c pconj (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pconj (const Packet4uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pconj (const Packet8uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pconj (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet4s pconj (const Packet4s &a)
 
template<>
EIGEN_STRONG_INLINE Packet8s pconj (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE Packet4us pconj (const Packet4us &a)
 
template<>
EIGEN_STRONG_INLINE Packet8us pconj (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE Packet2i pconj (const Packet2i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pconj (const Packet2ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d pconj (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pconj (const Packet4ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet2l pconj (const Packet2l &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pconj (const Packet2ul &a)
 
template<>
EIGEN_STRONG_INLINE Packet8h pconj (const Packet8h &a)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pconj (const Packet8bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet16h pconj (const Packet16h &a)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pconj (const Packet16bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pconj (const Packet4bf &a)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pcos (const Packet &a)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f pcos< Packet16f > (const Packet16f &_x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f pcos< Packet2f > (const Packet2f &x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f pcos< Packet4f > (const Packet4f &_x)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pcos< Packet8bf > (const Packet8bf &a)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f pcos< Packet8f > (const Packet8f &_x)
 
template<>
EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf pcos< PacketXf > (const PacketXf &x)
 
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet pcos_float (const Packet &x)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pcosh (const Packet &a)
 
EIGEN_STRONG_INLINE Packet2cf pcplxflip (const Packet2cf &x)
 
EIGEN_STRONG_INLINE Packet1cd pcplxflip (const Packet1cd &x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pcplxflip (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE Packet1cf pcplxflip< Packet1cf > (const Packet1cf &a)
 
template<>
EIGEN_STRONG_INLINE Packet2cd pcplxflip< Packet2cd > (const Packet2cd &x)
 
template<>
EIGEN_STRONG_INLINE Packet2cf pcplxflip< Packet2cf > (const Packet2cf &x)
 
template<>
EIGEN_STRONG_INLINE Packet4cd pcplxflip< Packet4cd > (const Packet4cd &x)
 
template<>
EIGEN_STRONG_INLINE Packet4cf pcplxflip< Packet4cf > (const Packet4cf &x)
 
template<>
EIGEN_STRONG_INLINE Packet8cf pcplxflip< Packet8cf > (const Packet8cf &x)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pdigamma (const Packet &a)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pdiv (const Packet &a, const Packet &b)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pdiv< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c pdiv< Packet16c > (const Packet16c &, const Packet16c &)
 
template<>
EIGEN_STRONG_INLINE Packet16f pdiv< Packet16f > (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet16h pdiv< Packet16h > (const Packet16h &a, const Packet16h &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pdiv< Packet16uc > (const Packet16uc &, const Packet16uc &)
 
template<>
EIGEN_STRONG_INLINE Packet1cd pdiv< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet1cf pdiv< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cd pdiv< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cf pdiv< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d pdiv< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f pdiv< Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2i pdiv< Packet2i > (const Packet2i &, const Packet2i &)
 
template<>
EIGEN_STRONG_INLINE Packet2l pdiv< Packet2l > (const Packet2l &, const Packet2l &)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pdiv< Packet2ui > (const Packet2ui &, const Packet2ui &)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pdiv< Packet2ul > (const Packet2ul &, const Packet2ul &)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pdiv< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4c pdiv< Packet4c > (const Packet4c &, const Packet4c &)
 
template<>
EIGEN_STRONG_INLINE Packet4cd pdiv< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet4cf pdiv< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d pdiv< Packet4d > (const Packet4d &a, const Packet4d &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 Packet4s pdiv< Packet4s > (const Packet4s &, const Packet4s &)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pdiv< Packet4uc > (const Packet4uc &, const Packet4uc &)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pdiv< Packet4ui > (const Packet4ui &, const Packet4ui &)
 
template<>
EIGEN_STRONG_INLINE Packet4us pdiv< Packet4us > (const Packet4us &, const Packet4us &)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pdiv< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8c pdiv< Packet8c > (const Packet8c &, const Packet8c &)
 
template<>
EIGEN_STRONG_INLINE Packet8cf pdiv< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d pdiv< Packet8d > (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f pdiv< Packet8f > (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8h pdiv< Packet8h > (const Packet8h &a, const Packet8h &b)
 
template<>
EIGEN_STRONG_INLINE Packet8i pdiv< Packet8i > (const Packet8i &, const Packet8i &)
 
template<>
EIGEN_STRONG_INLINE Packet8s pdiv< Packet8s > (const Packet8s &, const Packet8s &)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pdiv< Packet8uc > (const Packet8uc &, const Packet8uc &)
 
template<>
EIGEN_STRONG_INLINE Packet8us pdiv< Packet8us > (const Packet8us &, const Packet8us &)
 
template<>
EIGEN_STRONG_INLINE PacketXf pdiv< PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<>
EIGEN_STRONG_INLINE PacketXi pdiv< PacketXi > (const PacketXi &a, const PacketXi &b)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet perf (const Packet &a)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet perfc (const Packet &a)
 
template<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 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 _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<>
EIGEN_STRONG_INLINE Packet16f peven_mask (const Packet16f &)
 
template<>
EIGEN_STRONG_INLINE Packet16i peven_mask (const Packet16i &)
 
template<>
EIGEN_STRONG_INLINE Packet8d peven_mask (const Packet8d &)
 
template<>
EIGEN_STRONG_INLINE Packet8f peven_mask (const Packet8f &)
 
template<>
EIGEN_STRONG_INLINE Packet8i peven_mask (const Packet8i &)
 
template<>
EIGEN_STRONG_INLINE Packet4d peven_mask (const Packet4d &)
 
template<>
EIGEN_STRONG_INLINE Packet4f peven_mask (const Packet4f &)
 
template<>
EIGEN_STRONG_INLINE Packet4i peven_mask (const Packet4i &)
 
template<>
EIGEN_STRONG_INLINE Packet2d peven_mask (const Packet2d &)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet peven_mask (const Packet &)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pexp (const Packet &a)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d pexp< Packet2d > (const Packet2d &_x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f pexp< Packet2f > (const Packet2f &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 Packet4f pexp< Packet4f > (const Packet4f &_x)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pexp< Packet8bf > (const Packet8bf &a)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f pexp< Packet8f > (const Packet8f &_x)
 
template<>
EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf pexp< PacketXf > (const PacketXf &x)
 
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet pexp_double (const Packet _x)
 
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet pexp_float (const Packet _x)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pexpm1 (const Packet &a)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f pexpm1< Packet4f > (const Packet4f &_x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f pexpm1< Packet8f > (const Packet8f &_x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type pfirst (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE bfloat16 pfirst (const Packet8bf &a)
 
template<>
EIGEN_STRONG_INLINE bool pfirst< Packet16b > (const Packet16b &a)
 
template<>
EIGEN_STRONG_INLINE bfloat16 pfirst< Packet16bf > (const Packet16bf &from)
 
template<>
EIGEN_STRONG_INLINE signed char pfirst< Packet16c > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE int8_t pfirst< Packet16c > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE float pfirst< Packet16f > (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE Eigen::half pfirst< Packet16h > (const Packet16h &from)
 
template<>
EIGEN_STRONG_INLINE int pfirst< Packet16i > (const Packet16i &a)
 
template<>
EIGEN_STRONG_INLINE unsigned char pfirst< Packet16uc > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE uint8_t pfirst< Packet16uc > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< double > pfirst< Packet1cd > (const Packet1cd &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< float > pfirst< Packet1cf > (const Packet1cf &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< double > pfirst< Packet2cd > (const Packet2cd &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< float > pfirst< Packet2cf > (const Packet2cf &a)
 
template<>
EIGEN_STRONG_INLINE double pfirst< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE float pfirst< Packet2f > (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE int32_t pfirst< Packet2i > (const Packet2i &a)
 
template<>
EIGEN_STRONG_INLINE int64_t pfirst< Packet2l > (const Packet2l &a)
 
template<>
EIGEN_STRONG_INLINE uint32_t pfirst< Packet2ui > (const Packet2ui &a)
 
template<>
EIGEN_STRONG_INLINE uint64_t pfirst< Packet2ul > (const Packet2ul &a)
 
template<>
EIGEN_STRONG_INLINE bfloat16 pfirst< Packet4bf > (const Packet4bf &from)
 
template<>
EIGEN_STRONG_INLINE int8_t pfirst< Packet4c > (const Packet4c &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< double > pfirst< Packet4cd > (const Packet4cd &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< float > pfirst< Packet4cf > (const Packet4cf &a)
 
template<>
EIGEN_STRONG_INLINE double pfirst< Packet4d > (const Packet4d &a)
 
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 int pfirst< Packet4i > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE int16_t pfirst< Packet4s > (const Packet4s &a)
 
template<>
EIGEN_STRONG_INLINE uint8_t pfirst< Packet4uc > (const Packet4uc &a)
 
template<>
EIGEN_STRONG_INLINE uint32_t pfirst< Packet4ui > (const Packet4ui &a)
 
template<>
EIGEN_STRONG_INLINE uint16_t pfirst< Packet4us > (const Packet4us &a)
 
template<>
EIGEN_STRONG_INLINE bfloat16 pfirst< Packet8bf > (const Packet8bf &from)
 
template<>
EIGEN_STRONG_INLINE int8_t pfirst< Packet8c > (const Packet8c &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< float > pfirst< Packet8cf > (const Packet8cf &a)
 
template<>
EIGEN_STRONG_INLINE double pfirst< Packet8d > (const Packet8d &a)
 
template<>
EIGEN_STRONG_INLINE float pfirst< Packet8f > (const Packet8f &a)
 
template<>
EIGEN_STRONG_INLINE Eigen::half pfirst< Packet8h > (const Packet8h &from)
 
template<>
EIGEN_STRONG_INLINE int pfirst< Packet8i > (const Packet8i &a)
 
template<>
EIGEN_STRONG_INLINE short int pfirst< Packet8s > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE int16_t pfirst< Packet8s > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE uint8_t pfirst< Packet8uc > (const Packet8uc &a)
 
template<>
EIGEN_STRONG_INLINE unsigned short int pfirst< Packet8us > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE uint16_t pfirst< Packet8us > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE float pfirst< PacketXf > (const PacketXf &a)
 
template<>
EIGEN_STRONG_INLINE numext::int32_t pfirst< PacketXi > (const PacketXi &a)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pfloor (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pfloor< Packet16bf > (const Packet16bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet16f pfloor< Packet16f > (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE Packet16h pfloor< Packet16h > (const Packet16h &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d pfloor< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet2f pfloor< Packet2f > (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pfloor< Packet4bf > (const Packet4bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet4d pfloor< Packet4d > (const Packet4d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f pfloor< Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pfloor< Packet8bf > (const Packet8bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet8d pfloor< Packet8d > (const Packet8d &a)
 
template<>
EIGEN_STRONG_INLINE Packet8f pfloor< Packet8f > (const Packet8f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8h pfloor< Packet8h > (const Packet8h &a)
 
template<>
EIGEN_STRONG_INLINE PacketXf pfloor< PacketXf > (const PacketXf &a)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pfrexp (const Packet4bf &a, Packet4bf &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet8h pfrexp (const Packet8h &a, Packet8h &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pfrexp (const Packet8bf &a, Packet8bf &exponent)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pfrexp (const Packet &a, Packet &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet16f pfrexp< Packet16f > (const Packet16f &a, Packet16f &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet2d pfrexp< Packet2d > (const Packet2d &a, Packet2d &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet2f pfrexp< Packet2f > (const Packet2f &a, Packet2f &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet4d pfrexp< Packet4d > (const Packet4d &a, Packet4d &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet4f pfrexp< Packet4f > (const Packet4f &a, Packet4f &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pfrexp< Packet8bf > (const Packet8bf &a, Packet8bf &e)
 
template<>
EIGEN_STRONG_INLINE Packet8d pfrexp< Packet8d > (const Packet8d &a, Packet8d &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet8f pfrexp< Packet8f > (const Packet8f &a, Packet8f &exponent)
 
template<>
EIGEN_STRONG_INLINE PacketXf pfrexp< PacketXf > (const PacketXf &a, PacketXf &exponent)
 
template<typename Packet >
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet pfrexp_generic (const Packet &a, Packet &exponent)
 
template<typename Packet >
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet pfrexp_generic_get_biased_exponent (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE Packet4d pfrexp_generic_get_biased_exponent (const Packet4d &a)
 
template<>
EIGEN_STRONG_INLINE Packet8d pfrexp_generic_get_biased_exponent (const Packet8d &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d pfrexp_generic_get_biased_exponent (const Packet2d &a)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pgamma_sample_der_alpha (const Packet &alpha, const Packet &sample)
 
template<typename Scalar , typename Packet >
EIGEN_DEVICE_FUNC Packet pgather (const Scalar *from, Index)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pgather< bfloat16, Packet16bf > (const bfloat16 *from, Index stride)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pgather< bfloat16, Packet4bf > (const bfloat16 *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet8bf pgather< bfloat16, Packet8bf > (const bfloat16 *from, Index stride)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pgather< bfloat16, Packet8bf > (const bfloat16 *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet16b pgather< bool, Packet16b > (const bool *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet2d pgather< double, Packet2d > (const double *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet4d pgather< double, Packet4d > (const double *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet8d pgather< double, Packet8d > (const double *from, Index stride)
 
template<>
EIGEN_STRONG_INLINE Packet16h pgather< Eigen::half, Packet16h > (const Eigen::half *from, Index stride)
 
template<>
EIGEN_STRONG_INLINE Packet8h pgather< Eigen::half, Packet8h > (const Eigen::half *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet16f pgather< float, Packet16f > (const float *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2f pgather< float, Packet2f > (const float *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet4f pgather< float, Packet4f > (const float *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4f pgather< float, Packet4f > (const float *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet8f pgather< float, Packet8f > (const float *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC PacketXf pgather< float, PacketXf > (const float *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet4i pgather< int, Packet4i > (const int *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s pgather< int16_t, Packet4s > (const int16_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8s pgather< int16_t, Packet8s > (const int16_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2i pgather< int32_t, Packet2i > (const int32_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet4i pgather< int32_t, Packet4i > (const int32_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4i pgather< int32_t, Packet4i > (const int32_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2l pgather< int64_t, Packet2l > (const int64_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16c pgather< int8_t, Packet16c > (const int8_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4c pgather< int8_t, Packet4c > (const int8_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c pgather< int8_t, Packet8c > (const int8_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC PacketXi pgather< numext::int32_t, PacketXi > (const numext::int32_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet8s pgather< short int, Packet8s > (const short int *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet16c pgather< signed char, Packet16c > (const signed char *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 Packet1cd pgather< std::complex< double >, Packet1cd > (const std::complex< double > *from, Index stride __attribute__((unused)))
 
template<>
EIGEN_DEVICE_FUNC Packet2cd pgather< std::complex< double >, Packet2cd > (const std::complex< double > *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet4cd pgather< std::complex< double >, Packet4cd > (const std::complex< double > *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet1cf pgather< std::complex< float >, Packet1cf > (const std::complex< float > *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet2cf pgather< std::complex< float >, Packet2cf > (const std::complex< float > *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet4cf pgather< std::complex< float >, Packet4cf > (const std::complex< float > *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet8cf pgather< std::complex< float >, Packet8cf > (const std::complex< float > *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us pgather< uint16_t, Packet4us > (const uint16_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8us pgather< uint16_t, Packet8us > (const uint16_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ui pgather< uint32_t, Packet2ui > (const uint32_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4ui pgather< uint32_t, Packet4ui > (const uint32_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ul pgather< uint64_t, Packet2ul > (const uint64_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16uc pgather< uint8_t, Packet16uc > (const uint8_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4uc pgather< uint8_t, Packet4uc > (const uint8_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc pgather< uint8_t, Packet8uc > (const uint8_t *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet16uc pgather< unsigned char, Packet16uc > (const unsigned char *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet8us pgather< unsigned short int, Packet8us > (const unsigned short int *from, Index stride)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pgather_common (const __UNPACK_TYPE__(Packet) *from, Index stride)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pgather_size16 (const __UNPACK_TYPE__(Packet) *from, Index stride)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pgather_size8 (const __UNPACK_TYPE__(Packet) *from, Index stride)
 
template<int N, typename Scalar , typename Packet , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void pger (PacketBlock< Packet, N > *acc, const Scalar *lhs, const Packet *rhsV)
 
template<int N, typename Scalar , typename Packet , typename Index , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void pger (PacketBlock< Packet, N > *acc, const Scalar *lhs, const Packet *rhsV, Index remaining_rows)
 
template<typename Packet , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void pger_common (PacketBlock< Packet, 4 > *acc, const Packet &lhsV, const Packet *rhsV)
 
template<typename Packet , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void pger_common (PacketBlock< Packet, 1 > *acc, const Packet &lhsV, const Packet *rhsV)
 
template<int N, typename Scalar , typename Packet , bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_ALWAYS_INLINE void pgerc (PacketBlock< Packet, N > *accReal, PacketBlock< Packet, N > *accImag, const Scalar *lhs_ptr, const Scalar *lhs_ptr_imag, const Packet *rhsV, const Packet *rhsVi)
 
template<int N, typename Scalar , typename Packet , typename Index , bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_ALWAYS_INLINE void pgerc (PacketBlock< Packet, N > *accReal, PacketBlock< Packet, N > *accImag, const Scalar *lhs_ptr, const Scalar *lhs_ptr_imag, const Packet *rhsV, const Packet *rhsVi, Index remaining_rows)
 
template<int N, typename Packet , bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_ALWAYS_INLINE void pgerc_common (PacketBlock< Packet, N > *accReal, PacketBlock< Packet, N > *accImag, const Packet &lhsV, const Packet &lhsVi, const Packet *rhsV, const Packet *rhsVi)
 
template<typename Scalar , typename Packet , typename RhsPacket , bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_ALWAYS_INLINE void pgercMMA (__vector_quad *accReal, __vector_quad *accImag, const Packet &lhsV, const Packet &lhsVi, const RhsPacket &rhsV, const RhsPacket &rhsVi)
 
template<typename LhsPacket , typename RhsPacket , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void pgerMMA (__vector_quad *acc, const RhsPacket &a, const LhsPacket &b)
 
template<typename LhsPacket , typename RhsPacket , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void pgerMMA (__vector_quad *acc, const PacketBlock< Packet2d, 2 > &a, const Packet2d &b)
 
template<typename LhsPacket , typename RhsPacket , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void pgerMMA (__vector_quad *acc, const __vector_pair &a, const Packet2d &b)
 
template<typename LhsPacket , typename RhsPacket , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void pgerMMA (__vector_quad *, const __vector_pair &, const Packet4f &)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pigamma (const Packet &a, const Packet &x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pigamma_der_a (const Packet &a, const Packet &x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pigammac (const Packet &a, const Packet &x)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pldexp (const Packet4bf &a, const Packet4bf &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet8h pldexp (const Packet8h &a, const Packet8h &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pldexp (const Packet8bf &a, const Packet8bf &exponent)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pldexp (const Packet &a, const Packet &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet16f pldexp< Packet16f > (const Packet16f &a, const Packet16f &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet2d pldexp< Packet2d > (const Packet2d &a, const Packet2d &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet2f pldexp< Packet2f > (const Packet2f &a, const Packet2f &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet4d pldexp< Packet4d > (const Packet4d &a, const Packet4d &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet4f pldexp< Packet4f > (const Packet4f &a, const Packet4f &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pldexp< Packet8bf > (const Packet8bf &a, const Packet8bf &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet8d pldexp< Packet8d > (const Packet8d &a, const Packet8d &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet8f pldexp< Packet8f > (const Packet8f &a, const Packet8f &exponent)
 
template<>
EIGEN_STRONG_INLINE PacketXf pldexp< PacketXf > (const PacketXf &a, const PacketXf &exponent)
 
template<typename Packet >
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet pldexp_generic (const Packet &a, const Packet &exponent)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plgamma (const Packet &a)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pload (const typename unpacket_traits< Packet >::type *from)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pload1 (const typename unpacket_traits< Packet >::type *a)
 
template<>
EIGEN_STRONG_INLINE Packet16f pload1< Packet16f > (const float *from)
 
template<>
EIGEN_STRONG_INLINE Packet4d pload1< Packet4d > (const double *from)
 
template<>
EIGEN_STRONG_INLINE Packet4f pload1< Packet4f > (const float *from)
 
template<>
EIGEN_STRONG_INLINE Packet4i pload1< Packet4i > (const int32_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet8d pload1< Packet8d > (const double *from)
 
template<>
EIGEN_STRONG_INLINE Packet8f pload1< Packet8f > (const float *from)
 
EIGEN_STRONG_INLINE Packet2cf pload2 (const std::complex< float > *from0, const std::complex< float > *from1)
 
template<>
EIGEN_STRONG_INLINE Packet16b pload< Packet16b > (const bool *from)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pload< Packet16bf > (const bfloat16 *from)
 
template<>
EIGEN_STRONG_INLINE Packet16c pload< Packet16c > (const signed char *from)
 
template<>
EIGEN_STRONG_INLINE Packet16f pload< Packet16f > (const float *from)
 
template<>
EIGEN_STRONG_INLINE Packet16h pload< Packet16h > (const Eigen::half *from)
 
template<>
EIGEN_STRONG_INLINE Packet16i pload< Packet16i > (const int *from)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pload< Packet16uc > (const unsigned char *from)
 
template<>
EIGEN_STRONG_INLINE Packet1cd pload< Packet1cd > (const std::complex< double > *from)
 
template<>
EIGEN_STRONG_INLINE Packet1cf pload< Packet1cf > (const std::complex< float > *from)
 
template<>
EIGEN_STRONG_INLINE Packet2cd pload< Packet2cd > (const std::complex< double > *from)
 
template<>
EIGEN_STRONG_INLINE Packet2cf pload< Packet2cf > (const std::complex< float > *from)
 
template<>
EIGEN_STRONG_INLINE Packet2d pload< Packet2d > (const double *from)
 
template<>
EIGEN_STRONG_INLINE Packet2f pload< Packet2f > (const float *from)
 
template<>
EIGEN_STRONG_INLINE Packet2i pload< Packet2i > (const int32_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet2l pload< Packet2l > (const int64_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pload< Packet2ui > (const uint32_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pload< Packet2ul > (const uint64_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pload< Packet4bf > (const bfloat16 *from)
 
template<>
EIGEN_STRONG_INLINE Packet4c pload< Packet4c > (const int8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4cd pload< Packet4cd > (const std::complex< double > *from)
 
template<>
EIGEN_STRONG_INLINE Packet4cf pload< Packet4cf > (const std::complex< float > *from)
 
template<>
EIGEN_STRONG_INLINE Packet4d pload< Packet4d > (const double *from)
 
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 Packet4i pload< Packet4i > (const int *from)
 
template<>
EIGEN_STRONG_INLINE Packet4s pload< Packet4s > (const int16_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pload< Packet4uc > (const uint8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pload< Packet4ui > (const uint32_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4us pload< Packet4us > (const uint16_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pload< Packet8bf > (const bfloat16 *from)
 
template<>
EIGEN_STRONG_INLINE Packet8c pload< Packet8c > (const int8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet8cf pload< Packet8cf > (const std::complex< float > *from)
 
template<>
EIGEN_STRONG_INLINE Packet8d pload< Packet8d > (const double *from)
 
template<>
EIGEN_STRONG_INLINE Packet8f pload< Packet8f > (const float *from)
 
template<>
EIGEN_STRONG_INLINE Packet8h pload< Packet8h > (const Eigen::half *from)
 
template<>
EIGEN_STRONG_INLINE Packet8i pload< Packet8i > (const int *from)
 
template<>
EIGEN_STRONG_INLINE Packet8s pload< Packet8s > (const short int *from)
 
template<>
EIGEN_STRONG_INLINE Packet8s pload< Packet8s > (const int16_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pload< Packet8uc > (const uint8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet8us pload< Packet8us > (const unsigned short int *from)
 
template<>
EIGEN_STRONG_INLINE Packet8us pload< Packet8us > (const uint16_t *from)
 
template<>
EIGEN_STRONG_INLINE PacketXf pload< PacketXf > (const float *from)
 
template<>
EIGEN_STRONG_INLINE PacketXi pload< PacketXi > (const numext::int32_t *from)
 
template<typename Packet >
EIGEN_STRONG_INLINE Packet pload_common (const __UNPACK_TYPE__(Packet) *from)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet ploaddup (const typename unpacket_traits< Packet >::type *from)
 
template<>
EIGEN_STRONG_INLINE Packet16b ploaddup< Packet16b > (const bool *from)
 
template<>
EIGEN_STRONG_INLINE Packet16bf ploaddup< Packet16bf > (const bfloat16 *from)
 
template<>
EIGEN_STRONG_INLINE Packet16c ploaddup< Packet16c > (const signed char *from)
 
template<>
EIGEN_STRONG_INLINE Packet16f ploaddup< Packet16f > (const float *from)
 
template<>
EIGEN_STRONG_INLINE Packet16h ploaddup< Packet16h > (const Eigen::half *from)
 
template<>
EIGEN_STRONG_INLINE Packet16uc ploaddup< Packet16uc > (const unsigned char *from)
 
template<>
EIGEN_STRONG_INLINE Packet1cd ploaddup< Packet1cd > (const std::complex< double > *from)
 
template<>
EIGEN_STRONG_INLINE Packet1cf ploaddup< Packet1cf > (const std::complex< float > *from)
 
template<>
EIGEN_STRONG_INLINE Packet2cd ploaddup< Packet2cd > (const std::complex< double > *from)
 
template<>
EIGEN_STRONG_INLINE Packet2cf ploaddup< Packet2cf > (const std::complex< float > *from)
 
template<>
EIGEN_STRONG_INLINE Packet2d ploaddup< Packet2d > (const double *from)
 
template<>
EIGEN_STRONG_INLINE Packet2f ploaddup< Packet2f > (const float *from)
 
template<>
EIGEN_STRONG_INLINE Packet2i ploaddup< Packet2i > (const int32_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet2l ploaddup< Packet2l > (const int64_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet2ui ploaddup< Packet2ui > (const uint32_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet2ul ploaddup< Packet2ul > (const uint64_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4bf ploaddup< Packet4bf > (const bfloat16 *from)
 
template<>
EIGEN_STRONG_INLINE Packet4c ploaddup< Packet4c > (const int8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4cd ploaddup< Packet4cd > (const std::complex< double > *from)
 
template<>
EIGEN_STRONG_INLINE Packet4cf ploaddup< Packet4cf > (const std::complex< float > *from)
 
template<>
EIGEN_STRONG_INLINE Packet4d ploaddup< Packet4d > (const double *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 Packet4i ploaddup< Packet4i > (const int *from)
 
template<>
EIGEN_STRONG_INLINE Packet4s ploaddup< Packet4s > (const int16_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4uc ploaddup< Packet4uc > (const uint8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4ui ploaddup< Packet4ui > (const uint32_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4us ploaddup< Packet4us > (const uint16_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet8bf ploaddup< Packet8bf > (const bfloat16 *from)
 
template<>
EIGEN_STRONG_INLINE Packet8c ploaddup< Packet8c > (const int8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet8cf ploaddup< Packet8cf > (const std::complex< float > *from)
 
template<>
EIGEN_STRONG_INLINE Packet8d ploaddup< Packet8d > (const double *from)
 
template<>
EIGEN_STRONG_INLINE Packet8f ploaddup< Packet8f > (const float *from)
 
template<>
EIGEN_STRONG_INLINE Packet8h ploaddup< Packet8h > (const Eigen::half *from)
 
template<>
EIGEN_STRONG_INLINE Packet8s ploaddup< Packet8s > (const short int *from)
 
template<>
EIGEN_STRONG_INLINE Packet8s ploaddup< Packet8s > (const int16_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet8uc ploaddup< Packet8uc > (const uint8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet8us ploaddup< Packet8us > (const unsigned short int *from)
 
template<>
EIGEN_STRONG_INLINE Packet8us ploaddup< Packet8us > (const uint16_t *from)
 
template<>
EIGEN_STRONG_INLINE PacketXf ploaddup< PacketXf > (const float *from)
 
template<>
EIGEN_STRONG_INLINE PacketXi ploaddup< PacketXi > (const numext::int32_t *from)
 
template<typename Packet >
EIGEN_STRONG_INLINE Packet ploaddup_common (const __UNPACK_TYPE__(Packet) *from)
 
template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE Packet ploadLhs (const Scalar *lhs)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet ploadquad (const typename unpacket_traits< Packet >::type *from)
 
template<>
EIGEN_STRONG_INLINE Packet16h ploadquad (const Eigen::half *from)
 
template<>
EIGEN_STRONG_INLINE Packet16bf ploadquad (const bfloat16 *from)
 
template<>
EIGEN_STRONG_INLINE Packet16b ploadquad< Packet16b > (const bool *from)
 
template<>
EIGEN_STRONG_INLINE Packet16c ploadquad< Packet16c > (const int8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet16f ploadquad< Packet16f > (const float *from)
 
template<>
EIGEN_STRONG_INLINE Packet16uc ploadquad< Packet16uc > (const uint8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4c ploadquad< Packet4c > (const int8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4f ploadquad< Packet4f > (const float *from)
 
template<>
EIGEN_STRONG_INLINE Packet4i ploadquad< Packet4i > (const int32_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4uc ploadquad< Packet4uc > (const uint8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4ui ploadquad< Packet4ui > (const uint32_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet8bf ploadquad< Packet8bf > (const bfloat16 *from)
 
template<>
EIGEN_STRONG_INLINE Packet8c ploadquad< Packet8c > (const int8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet8cf ploadquad< Packet8cf > (const std::complex< float > *from)
 
template<>
EIGEN_STRONG_INLINE Packet8d ploadquad< Packet8d > (const double *from)
 
template<>
EIGEN_STRONG_INLINE Packet8f ploadquad< Packet8f > (const float *from)
 
template<>
EIGEN_STRONG_INLINE Packet8h ploadquad< Packet8h > (const Eigen::half *from)
 
template<>
EIGEN_STRONG_INLINE Packet8s ploadquad< Packet8s > (const short int *from)
 
template<>
EIGEN_STRONG_INLINE Packet8s ploadquad< Packet8s > (const int16_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet8uc ploadquad< Packet8uc > (const uint8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet8us ploadquad< Packet8us > (const unsigned short int *from)
 
template<>
EIGEN_STRONG_INLINE Packet8us ploadquad< Packet8us > (const uint16_t *from)
 
template<>
EIGEN_STRONG_INLINE PacketXf ploadquad< PacketXf > (const float *from)
 
template<>
EIGEN_STRONG_INLINE PacketXi ploadquad< PacketXi > (const numext::int32_t *from)
 
template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE Packet ploadRhs (const Scalar *rhs)
 
template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE void ploadRhsMMA (const Scalar *rhs, Packet &rhsV)
 
template<>
EIGEN_ALWAYS_INLINE void ploadRhsMMA (const float *, __vector_pair &)
 
template<>
EIGEN_ALWAYS_INLINE void ploadRhsMMA< double, __vector_pair > (const double *rhs, __vector_pair &rhsV)
 
template<>
EIGEN_ALWAYS_INLINE void ploadRhsMMA< double, PacketBlock< Packet2d, 2 > > (const double *rhs, PacketBlock< Packet2d, 2 > &rhsV)
 
template<typename packet_type , int Alignment>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type ploadt (const Eigen::TensorSycl::internal::RangeAccess< cl::sycl::access::mode::read_write, typename unpacket_traits< packet_type >::type > &from)
 
template<typename Packet , int Alignment>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt (const typename unpacket_traits< Packet >::type *from)
 
template<typename packet_type , int Alignment, typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type ploadt_ro (const Eigen::TensorSycl::internal::RangeAccess< cl::sycl::access::mode::read_write, T > &from)
 
template<typename Packet , int LoadMode>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt_ro (const typename unpacket_traits< Packet >::type *from)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet ploadu (const typename unpacket_traits< Packet >::type *from)
 
template<typename Packet >
EIGEN_DEVICE_FUNC enable_if< unpacket_traits< Packet >::masked_load_available, Packet >::type ploadu (const typename unpacket_traits< Packet >::type *from, typename unpacket_traits< Packet >::mask_t umask)
 
template<>
EIGEN_STRONG_INLINE Packet16b ploadu< Packet16b > (const bool *from)
 
template<>
EIGEN_STRONG_INLINE Packet16bf ploadu< Packet16bf > (const bfloat16 *from)
 
template<>
EIGEN_STRONG_INLINE Packet16c ploadu< Packet16c > (const signed char *from)
 
template<>
EIGEN_STRONG_INLINE Packet16f ploadu< Packet16f > (const float *from)
 
template<>
EIGEN_STRONG_INLINE Packet16f ploadu< Packet16f > (const float *from, uint16_t umask)
 
template<>
EIGEN_STRONG_INLINE Packet16h ploadu< Packet16h > (const Eigen::half *from)
 
template<>
EIGEN_STRONG_INLINE Packet16i ploadu< Packet16i > (const int *from)
 
template<>
EIGEN_STRONG_INLINE Packet16uc ploadu< Packet16uc > (const unsigned char *from)
 
template<>
EIGEN_STRONG_INLINE Packet1cd ploadu< Packet1cd > (const std::complex< double > *from)
 
template<>
EIGEN_STRONG_INLINE Packet1cf ploadu< Packet1cf > (const std::complex< float > *from)
 
template<>
EIGEN_STRONG_INLINE Packet2cd ploadu< Packet2cd > (const std::complex< double > *from)
 
template<>
EIGEN_STRONG_INLINE Packet2cf ploadu< Packet2cf > (const std::complex< float > *from)
 
template<>
EIGEN_STRONG_INLINE Packet2d ploadu< Packet2d > (const double *from)
 
template<>
EIGEN_STRONG_INLINE Packet2f ploadu< Packet2f > (const float *from)
 
template<>
EIGEN_STRONG_INLINE Packet2i ploadu< Packet2i > (const int32_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet2l ploadu< Packet2l > (const int64_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet2ui ploadu< Packet2ui > (const uint32_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet2ul ploadu< Packet2ul > (const uint64_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4bf ploadu< Packet4bf > (const bfloat16 *from)
 
template<>
EIGEN_STRONG_INLINE Packet4c ploadu< Packet4c > (const int8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4cd ploadu< Packet4cd > (const std::complex< double > *from)
 
template<>
EIGEN_STRONG_INLINE Packet4cf ploadu< Packet4cf > (const std::complex< float > *from)
 
template<>
EIGEN_STRONG_INLINE Packet4d ploadu< Packet4d > (const double *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 Packet4i ploadu< Packet4i > (const int *from)
 
template<>
EIGEN_STRONG_INLINE Packet4s ploadu< Packet4s > (const int16_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4uc ploadu< Packet4uc > (const uint8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4ui ploadu< Packet4ui > (const uint32_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet4us ploadu< Packet4us > (const uint16_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet8bf ploadu< Packet8bf > (const bfloat16 *from)
 
template<>
EIGEN_STRONG_INLINE Packet8c ploadu< Packet8c > (const int8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet8cf ploadu< Packet8cf > (const std::complex< float > *from)
 
template<>
EIGEN_STRONG_INLINE Packet8d ploadu< Packet8d > (const double *from)
 
template<>
EIGEN_STRONG_INLINE Packet8f ploadu< Packet8f > (const float *from)
 
template<>
EIGEN_STRONG_INLINE Packet8f ploadu< Packet8f > (const float *from, uint8_t umask)
 
template<>
EIGEN_STRONG_INLINE Packet8h ploadu< Packet8h > (const Eigen::half *from)
 
template<>
EIGEN_STRONG_INLINE Packet8i ploadu< Packet8i > (const int *from)
 
template<>
EIGEN_STRONG_INLINE Packet8s ploadu< Packet8s > (const short int *from)
 
template<>
EIGEN_STRONG_INLINE Packet8s ploadu< Packet8s > (const int16_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet8uc ploadu< Packet8uc > (const uint8_t *from)
 
template<>
EIGEN_STRONG_INLINE Packet8us ploadu< Packet8us > (const unsigned short int *from)
 
template<>
EIGEN_STRONG_INLINE Packet8us ploadu< Packet8us > (const uint16_t *from)
 
template<>
EIGEN_STRONG_INLINE PacketXf ploadu< PacketXf > (const float *from)
 
template<>
EIGEN_STRONG_INLINE PacketXi ploadu< PacketXi > (const numext::int32_t *from)
 
template<typename Packet >
EIGEN_STRONG_INLINE Packet ploadu_common (const __UNPACK_TYPE__(Packet) *from)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog (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 plog1p (const Packet &a)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f plog1p< Packet4f > (const Packet4f &_x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f plog1p< Packet8f > (const Packet8f &_x)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog2 (const Packet &a)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d plog2< Packet2d > (const Packet2d &_x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d plog2< Packet4d > (const Packet4d &_x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f plog2< Packet4f > (const Packet4f &_x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f plog2< Packet8f > (const Packet8f &_x)
 
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet plog2_double (const Packet _x)
 
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet plog2_float (const Packet _x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d plog< Packet2d > (const Packet2d &_x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f plog< Packet2f > (const Packet2f &x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d plog< Packet4d > (const Packet4d &_x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f plog< Packet4f > (const Packet4f &_x)
 
template<>
EIGEN_STRONG_INLINE Packet8bf plog< Packet8bf > (const Packet8bf &a)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f plog< Packet8f > (const Packet8f &_x)
 
template<>
EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf plog< PacketXf > (const PacketXf &x)
 
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet plog_double (const Packet _x)
 
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet plog_float (const Packet _x)
 
template<typename Packet , bool base2>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet plog_impl_double (const Packet _x)
 
template<typename Packet , bool base2>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet plog_impl_float (const Packet _x)
 
template<int N>
EIGEN_STRONG_INLINE PacketXi plogical_shift_left (PacketXi a)
 
template<int N>
EIGEN_STRONG_INLINE Packet8i plogical_shift_left (Packet8i a)
 
template<int N>
EIGEN_DEVICE_FUNC int plogical_shift_left (const int &a)
 
template<int N>
EIGEN_DEVICE_FUNC long int plogical_shift_left (const long int &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet16i plogical_shift_left (Packet16i a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4i plogical_shift_left (const Packet4i &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4f plogical_shift_left (const Packet4f &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4ui plogical_shift_left (const Packet4ui &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet8us plogical_shift_left (const Packet8us &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4c plogical_shift_left (Packet4c &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet8c plogical_shift_left (Packet8c a)
 
template<int N>
EIGEN_STRONG_INLINE Packet16c plogical_shift_left (Packet16c a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4uc plogical_shift_left (Packet4uc &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet8uc plogical_shift_left (Packet8uc a)
 
template<int N>
EIGEN_STRONG_INLINE Packet16uc plogical_shift_left (Packet16uc a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4s plogical_shift_left (Packet4s a)
 
template<int N>
EIGEN_STRONG_INLINE Packet8s plogical_shift_left (Packet8s a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4us plogical_shift_left (Packet4us a)
 
template<int N>
EIGEN_STRONG_INLINE Packet8us plogical_shift_left (Packet8us a)
 
template<int N>
EIGEN_STRONG_INLINE Packet2i plogical_shift_left (Packet2i a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4i plogical_shift_left (Packet4i a)
 
template<int N>
EIGEN_STRONG_INLINE Packet2ui plogical_shift_left (Packet2ui a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4ui plogical_shift_left (Packet4ui a)
 
template<int N>
EIGEN_STRONG_INLINE Packet2l plogical_shift_left (Packet2l a)
 
template<int N>
EIGEN_STRONG_INLINE Packet2ul plogical_shift_left (Packet2ul a)
 
template<int N>
EIGEN_STRONG_INLINE PacketXi plogical_shift_right (PacketXi a)
 
template<int N>
EIGEN_STRONG_INLINE Packet8i plogical_shift_right (Packet8i a)
 
template<int N>
EIGEN_DEVICE_FUNC int plogical_shift_right (const int &a)
 
template<int N>
EIGEN_DEVICE_FUNC long int plogical_shift_right (const long int &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet16i plogical_shift_right (Packet16i a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4i plogical_shift_right (const Packet4i &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4f plogical_shift_right (const Packet4f &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4ui plogical_shift_right (const Packet4ui &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet8us plogical_shift_right (const Packet8us &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4c plogical_shift_right (Packet4c &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet8c plogical_shift_right (Packet8c a)
 
template<int N>
EIGEN_STRONG_INLINE Packet16c plogical_shift_right (Packet16c a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4uc plogical_shift_right (Packet4uc &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet8uc plogical_shift_right (Packet8uc a)
 
template<int N>
EIGEN_STRONG_INLINE Packet16uc plogical_shift_right (Packet16uc a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4s plogical_shift_right (Packet4s a)
 
template<int N>
EIGEN_STRONG_INLINE Packet8s plogical_shift_right (Packet8s a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4us plogical_shift_right (Packet4us a)
 
template<int N>
EIGEN_STRONG_INLINE Packet8us plogical_shift_right (Packet8us a)
 
template<int N>
EIGEN_STRONG_INLINE Packet2i plogical_shift_right (Packet2i a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4i plogical_shift_right (Packet4i a)
 
template<int N>
EIGEN_STRONG_INLINE Packet2ui plogical_shift_right (Packet2ui a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4ui plogical_shift_right (Packet4ui a)
 
template<int N>
EIGEN_STRONG_INLINE Packet2l plogical_shift_right (Packet2l a)
 
template<int N>
EIGEN_STRONG_INLINE Packet2ul plogical_shift_right (Packet2ul a)
 
template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet plset (const typename unpacket_traits< Packet >::type &a)
 
template<>
EIGEN_STRONG_INLINE Packet16bf plset< Packet16bf > (const bfloat16 &a)
 
template<>
EIGEN_STRONG_INLINE Packet16c plset< Packet16c > (const signed char &a)
 
template<>
EIGEN_STRONG_INLINE Packet16f plset< Packet16f > (const float &a)
 
template<>
EIGEN_STRONG_INLINE Packet16h plset< Packet16h > (const half &a)
 
template<>
EIGEN_STRONG_INLINE Packet16uc plset< Packet16uc > (const unsigned char &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d plset< Packet2d > (const double &a)
 
template<>
EIGEN_STRONG_INLINE Packet2f plset< Packet2f > (const float &a)
 
template<>
EIGEN_STRONG_INLINE Packet2i plset< Packet2i > (const int32_t &a)
 
template<>
EIGEN_STRONG_INLINE Packet2l plset< Packet2l > (const int64_t &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ui plset< Packet2ui > (const uint32_t &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ul plset< Packet2ul > (const uint64_t &a)
 
template<>
EIGEN_STRONG_INLINE Packet4bf plset< Packet4bf > (const bfloat16 &a)
 
template<>
EIGEN_STRONG_INLINE Packet4c plset< Packet4c > (const int8_t &a)
 
template<>
EIGEN_STRONG_INLINE Packet4d plset< Packet4d > (const double &a)
 
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 Packet4i plset< Packet4i > (const int &a)
 
template<>
EIGEN_STRONG_INLINE Packet4s plset< Packet4s > (const int16_t &a)
 
template<>
EIGEN_STRONG_INLINE Packet4uc plset< Packet4uc > (const uint8_t &a)
 
template<>
EIGEN_STRONG_INLINE Packet4ui plset< Packet4ui > (const uint32_t &a)
 
template<>
EIGEN_STRONG_INLINE Packet4us plset< Packet4us > (const uint16_t &a)
 
template<>
EIGEN_STRONG_INLINE Packet8bf plset< Packet8bf > (const bfloat16 &a)
 
template<>
EIGEN_STRONG_INLINE Packet8c plset< Packet8c > (const int8_t &a)
 
template<>
EIGEN_STRONG_INLINE Packet8d plset< Packet8d > (const double &a)
 
template<>
EIGEN_STRONG_INLINE Packet8f plset< Packet8f > (const float &a)
 
template<>
EIGEN_STRONG_INLINE Packet8h plset< Packet8h > (const half &a)
 
template<>
EIGEN_STRONG_INLINE Packet8s plset< Packet8s > (const int16_t &a)
 
template<>
EIGEN_STRONG_INLINE Packet8s plset< Packet8s > (const short int &a)
 
template<>
EIGEN_STRONG_INLINE Packet8uc plset< Packet8uc > (const uint8_t &a)
 
template<>
EIGEN_STRONG_INLINE Packet8us plset< Packet8us > (const uint16_t &a)
 
template<>
EIGEN_STRONG_INLINE Packet8us plset< Packet8us > (const unsigned short int &a)
 
template<>
EIGEN_STRONG_INLINE PacketXf plset< PacketXf > (const float &a)
 
template<>
EIGEN_STRONG_INLINE PacketXi plset< PacketXi > (const numext::int32_t &a)
 
template<>
EIGEN_STRONG_INLINE PacketXi pmadd (const PacketXi &a, const PacketXi &b, const PacketXi &c)
 
template<>
EIGEN_STRONG_INLINE PacketXf pmadd (const PacketXf &a, const PacketXf &b, const PacketXf &c)
 
template<>
EIGEN_STRONG_INLINE Packet4f pmadd (const Packet4f &a, const Packet4f &b, const Packet4f &c)
 
template<>
EIGEN_STRONG_INLINE Packet4i pmadd (const Packet4i &a, const Packet4i &b, const Packet4i &c)
 
template<>
EIGEN_STRONG_INLINE Packet8s pmadd (const Packet8s &a, const Packet8s &b, const Packet8s &c)
 
template<>
EIGEN_STRONG_INLINE Packet8us pmadd (const Packet8us &a, const Packet8us &b, const Packet8us &c)
 
template<>
EIGEN_STRONG_INLINE Packet2d pmadd (const Packet2d &a, const Packet2d &b, const Packet2d &c)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pmadd (const Packet &a, const Packet &b, const Packet &c)
 
template<>
EIGEN_STRONG_INLINE Packet2f pmadd (const Packet2f &a, const Packet2f &b, const Packet2f &c)
 
template<>
EIGEN_STRONG_INLINE Packet4c pmadd (const Packet4c &a, const Packet4c &b, const Packet4c &c)
 
template<>
EIGEN_STRONG_INLINE Packet8c pmadd (const Packet8c &a, const Packet8c &b, const Packet8c &c)
 
template<>
EIGEN_STRONG_INLINE Packet16c pmadd (const Packet16c &a, const Packet16c &b, const Packet16c &c)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pmadd (const Packet4uc &a, const Packet4uc &b, const Packet4uc &c)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pmadd (const Packet8uc &a, const Packet8uc &b, const Packet8uc &c)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pmadd (const Packet16uc &a, const Packet16uc &b, const Packet16uc &c)
 
template<>
EIGEN_STRONG_INLINE Packet4s pmadd (const Packet4s &a, const Packet4s &b, const Packet4s &c)
 
template<>
EIGEN_STRONG_INLINE Packet4us pmadd (const Packet4us &a, const Packet4us &b, const Packet4us &c)
 
template<>
EIGEN_STRONG_INLINE Packet2i pmadd (const Packet2i &a, const Packet2i &b, const Packet2i &c)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pmadd (const Packet2ui &a, const Packet2ui &b, const Packet2ui &c)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pmadd (const Packet4ui &a, const Packet4ui &b, const Packet4ui &c)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pmadd (const Packet8bf &a, const Packet8bf &b, const Packet8bf &c)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pmax (const Packet &a, const Packet &b)
 
template<int NaNPropagation, typename Packet >
EIGEN_DEVICE_FUNC Packet pmax (const Packet &a, const Packet &b)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pmax< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c pmax< Packet16c > (const Packet16c &a, const Packet16c &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f pmax< Packet16f > (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet16h pmax< Packet16h > (const Packet16h &a, const Packet16h &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pmax< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d pmax< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f pmax< Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2i pmax< Packet2i > (const Packet2i &a, const Packet2i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2l pmax< Packet2l > (const Packet2l &a, const Packet2l &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pmax< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pmax< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pmax< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4c pmax< Packet4c > (const Packet4c &a, const Packet4c &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d pmax< Packet4d > (const Packet4d &a, const Packet4d &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 Packet4s pmax< Packet4s > (const Packet4s &a, const Packet4s &b)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pmax< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pmax< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet4us pmax< Packet4us > (const Packet4us &a, const Packet4us &b)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pmax< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8c pmax< Packet8c > (const Packet8c &a, const Packet8c &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d pmax< Packet8d > (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f pmax< Packet8f > (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8h pmax< Packet8h > (const Packet8h &a, const Packet8h &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s pmax< Packet8s > (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pmax< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us pmax< Packet8us > (const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_STRONG_INLINE PacketXf pmax< PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<>
EIGEN_STRONG_INLINE PacketXi pmax< PacketXi > (const PacketXi &a, const PacketXi &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f pmax< PropagateNaN, Packet16f > (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d pmax< PropagateNaN, Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f pmax< PropagateNaN, Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pmax< PropagateNaN, Packet4bf > (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d pmax< PropagateNaN, Packet4d > (const Packet4d &a, const Packet4d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f pmax< PropagateNaN, Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d pmax< PropagateNaN, Packet8d > (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f pmax< PropagateNaN, Packet8f > (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE PacketXf pmax< PropagateNaN, PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f pmax< PropagateNumbers, Packet16f > (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d pmax< PropagateNumbers, Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pmax< PropagateNumbers, Packet4bf > (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d pmax< PropagateNumbers, Packet4d > (const Packet4d &a, const Packet4d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f pmax< PropagateNumbers, Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d pmax< PropagateNumbers, Packet8d > (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f pmax< PropagateNumbers, Packet8f > (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE PacketXf pmax< PropagateNumbers, PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pmin (const Packet &a, const Packet &b)
 
template<int NaNPropagation, typename Packet >
EIGEN_DEVICE_FUNC Packet pmin (const Packet &a, const Packet &b)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pmin< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c pmin< Packet16c > (const Packet16c &a, const Packet16c &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f pmin< Packet16f > (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet16h pmin< Packet16h > (const Packet16h &a, const Packet16h &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pmin< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d pmin< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f pmin< Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2i pmin< Packet2i > (const Packet2i &a, const Packet2i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2l pmin< Packet2l > (const Packet2l &a, const Packet2l &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pmin< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pmin< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pmin< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4c pmin< Packet4c > (const Packet4c &a, const Packet4c &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d pmin< Packet4d > (const Packet4d &a, const Packet4d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f pmin< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i pmin< Packet4i > (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet4s pmin< Packet4s > (const Packet4s &a, const Packet4s &b)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pmin< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pmin< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet4us pmin< Packet4us > (const Packet4us &a, const Packet4us &b)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pmin< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8c pmin< Packet8c > (const Packet8c &a, const Packet8c &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d pmin< Packet8d > (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f pmin< Packet8f > (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8h pmin< Packet8h > (const Packet8h &a, const Packet8h &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s pmin< Packet8s > (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pmin< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us pmin< Packet8us > (const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_STRONG_INLINE PacketXf pmin< PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<>
EIGEN_STRONG_INLINE PacketXi pmin< PacketXi > (const PacketXi &a, const PacketXi &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f pmin< PropagateNaN, Packet16f > (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d pmin< PropagateNaN, Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f pmin< PropagateNaN, Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pmin< PropagateNaN, Packet4bf > (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d pmin< PropagateNaN, Packet4d > (const Packet4d &a, const Packet4d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f pmin< PropagateNaN, Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d pmin< PropagateNaN, Packet8d > (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f pmin< PropagateNaN, Packet8f > (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE PacketXf pmin< PropagateNaN, PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f pmin< PropagateNumbers, Packet16f > (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d pmin< PropagateNumbers, Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pmin< PropagateNumbers, Packet4bf > (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d pmin< PropagateNumbers, Packet4d > (const Packet4d &a, const Packet4d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f pmin< PropagateNumbers, Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d pmin< PropagateNumbers, Packet8d > (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f pmin< PropagateNumbers, Packet8f > (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE PacketXf pmin< PropagateNumbers, PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<typename Packet , typename Op >
EIGEN_STRONG_INLINE Packet pminmax_propagate_nan (const Packet &a, const Packet &b, Op op)
 
template<typename Packet , typename Op >
EIGEN_STRONG_INLINE Packet pminmax_propagate_numbers (const Packet &a, const Packet &b, Op op)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pmul (const Packet &a, const Packet &b)
 
template<>
EIGEN_DEVICE_FUNC bool pmul (const bool &a, const bool &b)
 
template<>
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<>
EIGEN_STRONG_INLINE Packet16b pmul< Packet16b > (const Packet16b &a, const Packet16b &b)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pmul< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c pmul< Packet16c > (const Packet16c &a, const Packet16c &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f pmul< Packet16f > (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet16h pmul< Packet16h > (const Packet16h &a, const Packet16h &b)
 
template<>
EIGEN_STRONG_INLINE Packet16i pmul< Packet16i > (const Packet16i &a, const Packet16i &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pmul< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet1cd pmul< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet1cf pmul< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cd pmul< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cf pmul< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d pmul< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f pmul< Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2i pmul< Packet2i > (const Packet2i &a, const Packet2i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2l pmul< Packet2l > (const Packet2l &a, const Packet2l &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pmul< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pmul< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pmul< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4c pmul< Packet4c > (const Packet4c &a, const Packet4c &b)
 
template<>
EIGEN_STRONG_INLINE Packet4cd pmul< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet4cf pmul< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d pmul< Packet4d > (const Packet4d &a, const Packet4d &b)
 
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 Packet4s pmul< Packet4s > (const Packet4s &a, const Packet4s &b)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pmul< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pmul< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet4us pmul< Packet4us > (const Packet4us &a, const Packet4us &b)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pmul< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8c pmul< Packet8c > (const Packet8c &a, const Packet8c &b)
 
template<>
EIGEN_STRONG_INLINE Packet8cf pmul< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d pmul< Packet8d > (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f pmul< Packet8f > (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8h pmul< Packet8h > (const Packet8h &a, const Packet8h &b)
 
template<>
EIGEN_STRONG_INLINE Packet8i pmul< Packet8i > (const Packet8i &a, const Packet8i &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s pmul< Packet8s > (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pmul< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us pmul< Packet8us > (const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_STRONG_INLINE PacketXf pmul< PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<>
EIGEN_STRONG_INLINE PacketXi pmul< PacketXi > (const PacketXi &a, const PacketXi &b)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pndtri (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE Packet8cf pnegate (const Packet8cf &a)
 
template<>
EIGEN_STRONG_INLINE Packet4cf pnegate (const Packet4cf &a)
 
template<>
EIGEN_STRONG_INLINE PacketXi pnegate (const PacketXi &a)
 
template<>
EIGEN_STRONG_INLINE Packet1cf pnegate (const Packet1cf &a)
 
template<>
EIGEN_STRONG_INLINE Packet2cf pnegate (const Packet2cf &a)
 
template<>
EIGEN_STRONG_INLINE Packet4cd pnegate (const Packet4cd &a)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pnegate (const Packet &a)
 
template<>
EIGEN_DEVICE_FUNC bool pnegate (const bool &a)
 
template<>
EIGEN_STRONG_INLINE Packet2cd pnegate (const Packet2cd &a)
 
template<>
EIGEN_STRONG_INLINE Packet8f pnegate (const Packet8f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4d pnegate (const Packet4d &a)
 
template<>
EIGEN_STRONG_INLINE Packet16f pnegate (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8d pnegate (const Packet8d &a)
 
template<>
EIGEN_STRONG_INLINE Packet16b pnegate (const Packet16b &a)
 
template<>
EIGEN_STRONG_INLINE PacketXf pnegate (const PacketXf &a)
 
template<>
EIGEN_STRONG_INLINE Packet1cd pnegate (const Packet1cd &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f pnegate (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i pnegate (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2f pnegate (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4c pnegate (const Packet4c &a)
 
template<>
EIGEN_STRONG_INLINE Packet8c pnegate (const Packet8c &a)
 
template<>
EIGEN_STRONG_INLINE Packet16c pnegate (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE Packet4s pnegate (const Packet4s &a)
 
template<>
EIGEN_STRONG_INLINE Packet8s pnegate (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE Packet2i pnegate (const Packet2i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2l pnegate (const Packet2l &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d pnegate (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet8h pnegate (const Packet8h &a)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pnegate (const Packet8bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet16h pnegate (const Packet16h &a)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pnegate (const Packet16bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pnegate< Packet4bf > (const Packet4bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pnegate< Packet8bf > (const Packet8bf &a)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pnot (const Packet &a)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet por (const Packet &a, const Packet &b)
 
template<>
EIGEN_STRONG_INLINE Packet8h por (const Packet8h &a, const Packet8h &b)
 
template<>
EIGEN_STRONG_INLINE Packet8bf por (const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16h por (const Packet16h &a, const Packet16h &b)
 
template<>
EIGEN_STRONG_INLINE Packet16bf por (const Packet16bf &a, const Packet16bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf por (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16b por< Packet16b > (const Packet16b &a, const Packet16b &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c por< Packet16c > (const Packet16c &a, const Packet16c &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f por< Packet16f > (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet16i por< Packet16i > (const Packet16i &a, const Packet16i &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc por< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet1cd por< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet1cf por< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cd por< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cf por< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d por< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f por< Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2i por< Packet2i > (const Packet2i &a, const Packet2i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2l por< Packet2l > (const Packet2l &a, const Packet2l &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ui por< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ul por< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
 
template<>
EIGEN_STRONG_INLINE Packet4c por< Packet4c > (const Packet4c &a, const Packet4c &b)
 
template<>
EIGEN_STRONG_INLINE Packet4cd por< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet4cf por< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d por< Packet4d > (const Packet4d &a, const Packet4d &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 Packet4s por< Packet4s > (const Packet4s &a, const Packet4s &b)
 
template<>
EIGEN_STRONG_INLINE Packet4uc por< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet4ui por< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet4us por< Packet4us > (const Packet4us &a, const Packet4us &b)
 
template<>
EIGEN_STRONG_INLINE Packet8bf por< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8c por< Packet8c > (const Packet8c &a, const Packet8c &b)
 
template<>
EIGEN_STRONG_INLINE Packet8cf por< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d por< Packet8d > (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f por< Packet8f > (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8i por< Packet8i > (const Packet8i &a, const Packet8i &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s por< Packet8s > (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet8uc por< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us por< Packet8us > (const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_STRONG_INLINE PacketXf por< PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<>
EIGEN_STRONG_INLINE PacketXi por< PacketXi > (const PacketXi &a, const PacketXi &b)
 
template<typename RealScalar >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE RealScalar positive_real_hypot (const RealScalar &x, const RealScalar &y)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet ppolygamma (const Packet &n, const Packet &x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type predux (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE bool predux< Packet16b > (const Packet16b &a)
 
template<>
EIGEN_STRONG_INLINE bfloat16 predux< Packet16bf > (const Packet16bf &p)
 
template<>
EIGEN_STRONG_INLINE signed char predux< Packet16c > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE int8_t predux< Packet16c > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE float predux< Packet16f > (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE half predux< Packet16h > (const Packet16h &from)
 
template<>
EIGEN_STRONG_INLINE unsigned char predux< Packet16uc > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE uint8_t predux< Packet16uc > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< double > predux< Packet1cd > (const Packet1cd &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< float > predux< Packet1cf > (const Packet1cf &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< double > predux< Packet2cd > (const Packet2cd &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< float > predux< Packet2cf > (const Packet2cf &a)
 
template<>
EIGEN_STRONG_INLINE double predux< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE float predux< Packet2f > (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE int32_t predux< Packet2i > (const Packet2i &a)
 
template<>
EIGEN_STRONG_INLINE int64_t predux< Packet2l > (const Packet2l &a)
 
template<>
EIGEN_STRONG_INLINE uint32_t predux< Packet2ui > (const Packet2ui &a)
 
template<>
EIGEN_STRONG_INLINE uint64_t predux< Packet2ul > (const Packet2ul &a)
 
template<>
EIGEN_STRONG_INLINE bfloat16 predux< Packet4bf > (const Packet4bf &a)
 
template<>
EIGEN_STRONG_INLINE int8_t predux< Packet4c > (const Packet4c &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< double > predux< Packet4cd > (const Packet4cd &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< float > predux< Packet4cf > (const Packet4cf &a)
 
template<>
EIGEN_STRONG_INLINE double predux< Packet4d > (const Packet4d &a)
 
template<>
EIGEN_STRONG_INLINE float predux< Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE int32_t predux< Packet4i > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE int predux< Packet4i > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE int16_t predux< Packet4s > (const Packet4s &a)
 
template<>
EIGEN_STRONG_INLINE uint8_t predux< Packet4uc > (const Packet4uc &a)
 
template<>
EIGEN_STRONG_INLINE uint32_t predux< Packet4ui > (const Packet4ui &a)
 
template<>
EIGEN_STRONG_INLINE uint16_t predux< Packet4us > (const Packet4us &a)
 
template<>
EIGEN_STRONG_INLINE bfloat16 predux< Packet8bf > (const Packet8bf &a)
 
template<>
EIGEN_STRONG_INLINE int8_t predux< Packet8c > (const Packet8c &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< float > predux< Packet8cf > (const Packet8cf &a)
 
template<>
EIGEN_STRONG_INLINE double predux< Packet8d > (const Packet8d &a)
 
template<>
EIGEN_STRONG_INLINE float predux< Packet8f > (const Packet8f &a)
 
template<>
EIGEN_STRONG_INLINE Eigen::half predux< Packet8h > (const Packet8h &a)
 
template<>
EIGEN_STRONG_INLINE short int predux< Packet8s > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE int16_t predux< Packet8s > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE uint8_t predux< Packet8uc > (const Packet8uc &a)
 
template<>
EIGEN_STRONG_INLINE unsigned short int predux< Packet8us > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE uint16_t predux< Packet8us > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE float predux< PacketXf > (const PacketXf &a)
 
template<>
EIGEN_STRONG_INLINE numext::int32_t predux< PacketXi > (const PacketXi &a)
 
template<>
EIGEN_STRONG_INLINE bool predux_any (const Packet8f &x)
 
template<typename Packet >
EIGEN_DEVICE_FUNC bool predux_any (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE bool predux_any (const Packet16f &x)
 
template<>
EIGEN_STRONG_INLINE bool predux_any (const Packet4f &x)
 
template<typename Packet >
const DoublePacket< Packet > & predux_half_dowto4 (const DoublePacket< Packet > &a, typename enable_if< unpacket_traits< Packet >::size<=8 >::type *=0)
 
template<typename Packet >
DoublePacket< typename unpacket_traits< Packet >::halfpredux_half_dowto4 (const DoublePacket< Packet > &a, typename enable_if< unpacket_traits< Packet >::size==16 >::type *=0)
 
template<typename Packet >
EIGEN_DEVICE_FUNC conditional<(unpacket_traits< Packet >::size%8)==0, typename unpacket_traits< Packet >::half, Packet >::type predux_half_dowto4 (const Packet &a)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4c predux_half_dowto4 (const Packet8c &a)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c predux_half_dowto4 (const Packet16c &a)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4uc predux_half_dowto4 (const Packet8uc &a)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc predux_half_dowto4 (const Packet16uc &a)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s predux_half_dowto4 (const Packet8s &a)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us predux_half_dowto4 (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE Packet8bf predux_half_dowto4< Packet16bf > (const Packet16bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet8f predux_half_dowto4< Packet16f > (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8h predux_half_dowto4< Packet16h > (const Packet16h &a)
 
template<>
EIGEN_STRONG_INLINE Packet4cf predux_half_dowto4< Packet8cf > (const Packet8cf &a)
 
template<>
EIGEN_STRONG_INLINE Packet4d predux_half_dowto4< Packet8d > (const Packet8d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f predux_half_dowto4< Packet8f > (const Packet8f &a)
 
template<typename Packet , typename Op >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type predux_helper (const Packet &a, Op op)
 
template<typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type predux_max (const Packet &a)
 
template<int NaNPropagation, typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type predux_max (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE bfloat16 predux_max< Packet16bf > (const Packet16bf &from)
 
template<>
EIGEN_STRONG_INLINE signed char predux_max< Packet16c > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE int8_t predux_max< Packet16c > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE float predux_max< Packet16f > (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE Eigen::half predux_max< Packet16h > (const Packet16h &a)
 
template<>
EIGEN_STRONG_INLINE unsigned char predux_max< Packet16uc > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE uint8_t predux_max< Packet16uc > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE double predux_max< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE float predux_max< Packet2f > (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE int32_t predux_max< Packet2i > (const Packet2i &a)
 
template<>
EIGEN_STRONG_INLINE int64_t predux_max< Packet2l > (const Packet2l &a)
 
template<>
EIGEN_STRONG_INLINE uint32_t predux_max< Packet2ui > (const Packet2ui &a)
 
template<>
EIGEN_STRONG_INLINE uint64_t predux_max< Packet2ul > (const Packet2ul &a)
 
template<>
EIGEN_STRONG_INLINE bfloat16 predux_max< Packet4bf > (const Packet4bf &a)
 
template<>
EIGEN_STRONG_INLINE int8_t predux_max< Packet4c > (const Packet4c &a)
 
template<>
EIGEN_STRONG_INLINE double predux_max< Packet4d > (const Packet4d &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 int predux_max< Packet4i > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE int16_t predux_max< Packet4s > (const Packet4s &a)
 
template<>
EIGEN_STRONG_INLINE uint8_t predux_max< Packet4uc > (const Packet4uc &a)
 
template<>
EIGEN_STRONG_INLINE uint32_t predux_max< Packet4ui > (const Packet4ui &a)
 
template<>
EIGEN_STRONG_INLINE uint16_t predux_max< Packet4us > (const Packet4us &a)
 
template<>
EIGEN_STRONG_INLINE bfloat16 predux_max< Packet8bf > (const Packet8bf &a)
 
template<>
EIGEN_STRONG_INLINE int8_t predux_max< Packet8c > (const Packet8c &a)
 
template<>
EIGEN_STRONG_INLINE double predux_max< Packet8d > (const Packet8d &a)
 
template<>
EIGEN_STRONG_INLINE float predux_max< Packet8f > (const Packet8f &a)
 
template<>
EIGEN_STRONG_INLINE Eigen::half predux_max< Packet8h > (const Packet8h &a)
 
template<>
EIGEN_STRONG_INLINE short int predux_max< Packet8s > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE int16_t predux_max< Packet8s > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE uint8_t predux_max< Packet8uc > (const Packet8uc &a)
 
template<>
EIGEN_STRONG_INLINE unsigned short int predux_max< Packet8us > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE uint16_t predux_max< Packet8us > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE float predux_max< PacketXf > (const PacketXf &a)
 
template<>
EIGEN_STRONG_INLINE numext::int32_t predux_max< PacketXi > (const PacketXi &a)
 
template<typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type predux_min (const Packet &a)
 
template<int NaNPropagation, typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type predux_min (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE bfloat16 predux_min< Packet16bf > (const Packet16bf &from)
 
template<>
EIGEN_STRONG_INLINE signed char predux_min< Packet16c > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE int8_t predux_min< Packet16c > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE float predux_min< Packet16f > (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE Eigen::half predux_min< Packet16h > (const Packet16h &a)
 
template<>
EIGEN_STRONG_INLINE unsigned char predux_min< Packet16uc > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE uint8_t predux_min< Packet16uc > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE double predux_min< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE float predux_min< Packet2f > (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE int32_t predux_min< Packet2i > (const Packet2i &a)
 
template<>
EIGEN_STRONG_INLINE int64_t predux_min< Packet2l > (const Packet2l &a)
 
template<>
EIGEN_STRONG_INLINE uint32_t predux_min< Packet2ui > (const Packet2ui &a)
 
template<>
EIGEN_STRONG_INLINE uint64_t predux_min< Packet2ul > (const Packet2ul &a)
 
template<>
EIGEN_STRONG_INLINE bfloat16 predux_min< Packet4bf > (const Packet4bf &a)
 
template<>
EIGEN_STRONG_INLINE int8_t predux_min< Packet4c > (const Packet4c &a)
 
template<>
EIGEN_STRONG_INLINE double predux_min< Packet4d > (const Packet4d &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 int predux_min< Packet4i > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE int16_t predux_min< Packet4s > (const Packet4s &a)
 
template<>
EIGEN_STRONG_INLINE uint8_t predux_min< Packet4uc > (const Packet4uc &a)
 
template<>
EIGEN_STRONG_INLINE uint32_t predux_min< Packet4ui > (const Packet4ui &a)
 
template<>
EIGEN_STRONG_INLINE uint16_t predux_min< Packet4us > (const Packet4us &a)
 
template<>
EIGEN_STRONG_INLINE bfloat16 predux_min< Packet8bf > (const Packet8bf &a)
 
template<>
EIGEN_STRONG_INLINE int8_t predux_min< Packet8c > (const Packet8c &a)
 
template<>
EIGEN_STRONG_INLINE double predux_min< Packet8d > (const Packet8d &a)
 
template<>
EIGEN_STRONG_INLINE float predux_min< Packet8f > (const Packet8f &a)
 
template<>
EIGEN_STRONG_INLINE Eigen::half predux_min< Packet8h > (const Packet8h &a)
 
template<>
EIGEN_STRONG_INLINE short int predux_min< Packet8s > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE int16_t predux_min< Packet8s > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE uint8_t predux_min< Packet8uc > (const Packet8uc &a)
 
template<>
EIGEN_STRONG_INLINE unsigned short int predux_min< Packet8us > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE uint16_t predux_min< Packet8us > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE float predux_min< PacketXf > (const PacketXf &a)
 
template<>
EIGEN_STRONG_INLINE numext::int32_t predux_min< PacketXi > (const PacketXi &a)
 
template<typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits< Packet >::type predux_mul (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE bool predux_mul< Packet16b > (const Packet16b &a)
 
template<>
EIGEN_STRONG_INLINE bfloat16 predux_mul< Packet16bf > (const Packet16bf &from)
 
template<>
EIGEN_STRONG_INLINE signed char predux_mul< Packet16c > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE int8_t predux_mul< Packet16c > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE float predux_mul< Packet16f > (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE half predux_mul< Packet16h > (const Packet16h &from)
 
template<>
EIGEN_STRONG_INLINE unsigned char predux_mul< Packet16uc > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE uint8_t predux_mul< Packet16uc > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< double > predux_mul< Packet1cd > (const Packet1cd &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< float > predux_mul< Packet1cf > (const Packet1cf &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< double > predux_mul< Packet2cd > (const Packet2cd &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< float > predux_mul< Packet2cf > (const Packet2cf &a)
 
template<>
EIGEN_STRONG_INLINE double predux_mul< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE float predux_mul< Packet2f > (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE int32_t predux_mul< Packet2i > (const Packet2i &a)
 
template<>
EIGEN_STRONG_INLINE int64_t predux_mul< Packet2l > (const Packet2l &a)
 
template<>
EIGEN_STRONG_INLINE uint32_t predux_mul< Packet2ui > (const Packet2ui &a)
 
template<>
EIGEN_STRONG_INLINE uint64_t predux_mul< Packet2ul > (const Packet2ul &a)
 
template<>
EIGEN_STRONG_INLINE bfloat16 predux_mul< Packet4bf > (const Packet4bf &a)
 
template<>
EIGEN_STRONG_INLINE int8_t predux_mul< Packet4c > (const Packet4c &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< double > predux_mul< Packet4cd > (const Packet4cd &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< float > predux_mul< Packet4cf > (const Packet4cf &a)
 
template<>
EIGEN_STRONG_INLINE double predux_mul< Packet4d > (const Packet4d &a)
 
template<>
EIGEN_STRONG_INLINE float predux_mul< Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE int32_t predux_mul< Packet4i > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE int predux_mul< Packet4i > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE int16_t predux_mul< Packet4s > (const Packet4s &a)
 
template<>
EIGEN_STRONG_INLINE uint8_t predux_mul< Packet4uc > (const Packet4uc &a)
 
template<>
EIGEN_STRONG_INLINE uint32_t predux_mul< Packet4ui > (const Packet4ui &a)
 
template<>
EIGEN_STRONG_INLINE uint16_t predux_mul< Packet4us > (const Packet4us &a)
 
template<>
EIGEN_STRONG_INLINE bfloat16 predux_mul< Packet8bf > (const Packet8bf &a)
 
template<>
EIGEN_STRONG_INLINE int8_t predux_mul< Packet8c > (const Packet8c &a)
 
template<>
EIGEN_STRONG_INLINE std::complex< float > predux_mul< Packet8cf > (const Packet8cf &a)
 
template<>
EIGEN_STRONG_INLINE double predux_mul< Packet8d > (const Packet8d &a)
 
template<>
EIGEN_STRONG_INLINE float predux_mul< Packet8f > (const Packet8f &a)
 
template<>
EIGEN_STRONG_INLINE Eigen::half predux_mul< Packet8h > (const Packet8h &a)
 
template<>
EIGEN_STRONG_INLINE short int predux_mul< Packet8s > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE int16_t predux_mul< Packet8s > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE uint8_t predux_mul< Packet8uc > (const Packet8uc &a)
 
template<>
EIGEN_STRONG_INLINE unsigned short int predux_mul< Packet8us > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE uint16_t predux_mul< Packet8us > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE float predux_mul< PacketXf > (const PacketXf &a)
 
template<>
EIGEN_STRONG_INLINE numext::int32_t predux_mul< PacketXi > (const PacketXi &a)
 
template<typename Scalar >
EIGEN_DEVICE_FUNC void prefetch (const Scalar *addr)
 
template<>
EIGEN_STRONG_INLINE void prefetch< double > (const double *addr)
 
template<>
EIGEN_STRONG_INLINE void prefetch< float > (const float *addr)
 
template<>
EIGEN_STRONG_INLINE void prefetch< int > (const int *addr)
 
template<>
EIGEN_STRONG_INLINE void prefetch< int16_t > (const int16_t *addr)
 
template<>
EIGEN_STRONG_INLINE void prefetch< int32_t > (const int32_t *addr)
 
template<>
EIGEN_STRONG_INLINE void prefetch< int64_t > (const int64_t *addr)
 
template<>
EIGEN_STRONG_INLINE void prefetch< int8_t > (const int8_t *addr)
 
template<>
EIGEN_STRONG_INLINE void prefetch< numext::int32_t > (const numext::int32_t *addr)
 
template<>
EIGEN_STRONG_INLINE void prefetch< std::complex< double > > (const std::complex< double > *addr)
 
template<>
EIGEN_STRONG_INLINE void prefetch< std::complex< float > > (const std::complex< float > *addr)
 
template<>
EIGEN_STRONG_INLINE void prefetch< uint16_t > (const uint16_t *addr)
 
template<>
EIGEN_STRONG_INLINE void prefetch< uint32_t > (const uint32_t *addr)
 
template<>
EIGEN_STRONG_INLINE void prefetch< uint64_t > (const uint64_t *addr)
 
template<>
EIGEN_STRONG_INLINE void prefetch< uint8_t > (const uint8_t *addr)
 
template<typename Target , typename Packet >
EIGEN_DEVICE_FUNC Target preinterpret (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE Packet16c preinterpret< Packet16c, Packet16uc > (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet16f preinterpret< Packet16f, Packet16i > (const Packet16i &a)
 
template<>
EIGEN_STRONG_INLINE Packet16i preinterpret< Packet16i, Packet16f > (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE Packet16uc preinterpret< Packet16uc, Packet16c > (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d preinterpret< Packet2d, Packet4i > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2f preinterpret< Packet2f, Packet2i > (const Packet2i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2f preinterpret< Packet2f, Packet2ui > (const Packet2ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet2i preinterpret< Packet2i, Packet2f > (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE Packet2i preinterpret< Packet2i, Packet2ui > (const Packet2ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet2l preinterpret< Packet2l, Packet2ul > (const Packet2ul &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ui preinterpret< Packet2ui, Packet2f > (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ui preinterpret< Packet2ui, Packet2i > (const Packet2i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ul preinterpret< Packet2ul, Packet2l > (const Packet2l &a)
 
template<>
EIGEN_STRONG_INLINE Packet4c preinterpret< Packet4c, Packet4uc > (const Packet4uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f preinterpret< Packet4f, Packet4i > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f preinterpret< Packet4f, Packet4ui > (const Packet4ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i preinterpret< Packet4i, Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i preinterpret< Packet4i, Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i preinterpret< Packet4i, Packet4ui > (const Packet4ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet4s preinterpret< Packet4s, Packet4us > (const Packet4us &a)
 
template<>
EIGEN_STRONG_INLINE Packet4uc preinterpret< Packet4uc, Packet4c > (const Packet4c &a)
 
template<>
EIGEN_STRONG_INLINE Packet4ui preinterpret< Packet4ui, Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4ui preinterpret< Packet4ui, Packet4i > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet4us preinterpret< Packet4us, Packet4s > (const Packet4s &a)
 
template<>
EIGEN_STRONG_INLINE Packet8c preinterpret< Packet8c, Packet8uc > (const Packet8uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet8f preinterpret< Packet8f, Packet8i > (const Packet8i &a)
 
template<>
EIGEN_STRONG_INLINE Packet8i preinterpret< Packet8i, Packet8f > (const Packet8f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8s preinterpret< Packet8s, Packet8us > (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE Packet8uc preinterpret< Packet8uc, Packet8c > (const Packet8c &a)
 
template<>
EIGEN_STRONG_INLINE Packet8us preinterpret< Packet8us, Packet8s > (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE PacketXf preinterpret< PacketXf, PacketXi > (const PacketXi &a)
 
template<>
EIGEN_STRONG_INLINE PacketXi preinterpret< PacketXi, PacketXf > (const PacketXf &a)
 
template<>
EIGEN_STRONG_INLINE Packet8cf preverse (const Packet8cf &a)
 
template<>
EIGEN_STRONG_INLINE Packet4cf preverse (const Packet4cf &a)
 
template<>
EIGEN_STRONG_INLINE Packet2cf preverse (const Packet2cf &a)
 
template<>
EIGEN_STRONG_INLINE PacketXi preverse (const PacketXi &a)
 
template<>
EIGEN_STRONG_INLINE Packet1cf preverse (const Packet1cf &a)
 
template<>
EIGEN_STRONG_INLINE Packet4cd preverse (const Packet4cd &a)
 
template<>
EIGEN_STRONG_INLINE Packet2cd preverse (const Packet2cd &a)
 
template<>
EIGEN_STRONG_INLINE Packet1cd preverse (const Packet1cd &a)
 
template<>
EIGEN_STRONG_INLINE PacketXf preverse (const PacketXf &a)
 
template<>
EIGEN_STRONG_INLINE Packet8f preverse (const Packet8f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4d preverse (const Packet4d &a)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet preverse (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE Packet16f preverse (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8d preverse (const Packet8d &a)
 
template<>
EIGEN_STRONG_INLINE Packet16b preverse (const Packet16b &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d preverse (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f preverse (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i preverse (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet8s preverse (const Packet8s &a)
 
template<>
EIGEN_STRONG_INLINE Packet8us preverse (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE Packet16c preverse (const Packet16c &a)
 
template<>
EIGEN_STRONG_INLINE Packet16uc preverse (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet8bf preverse (const Packet8bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet8h preverse (const Packet8h &a)
 
template<>
EIGEN_STRONG_INLINE Packet16h preverse (const Packet16h &a)
 
template<>
EIGEN_STRONG_INLINE Packet16bf preverse (const Packet16bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet2f preverse (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4c preverse (const Packet4c &a)
 
template<>
EIGEN_STRONG_INLINE Packet8c preverse (const Packet8c &a)
 
template<>
EIGEN_STRONG_INLINE Packet4uc preverse (const Packet4uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet8uc preverse (const Packet8uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet4s preverse (const Packet4s &a)
 
template<>
EIGEN_STRONG_INLINE Packet4us preverse (const Packet4us &a)
 
template<>
EIGEN_STRONG_INLINE Packet2i preverse (const Packet2i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ui preverse (const Packet2ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet4ui preverse (const Packet4ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet2l preverse (const Packet2l &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ul preverse (const Packet2ul &a)
 
template<>
EIGEN_STRONG_INLINE Packet4bf preverse< Packet4bf > (const Packet4bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d print (const Packet2d &a)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet print (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f print (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet2f print (const Packet2f &a)
 
template<>
EIGEN_STRONG_INLINE Packet16bf print< Packet16bf > (const Packet16bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet16f print< Packet16f > (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE Packet16h print< Packet16h > (const Packet16h &a)
 
template<>
EIGEN_STRONG_INLINE Packet4bf print< Packet4bf > (const Packet4bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet4d print< Packet4d > (const Packet4d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f print< Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8bf print< Packet8bf > (const Packet8bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet8d print< Packet8d > (const Packet8d &a)
 
template<>
EIGEN_STRONG_INLINE Packet8f print< Packet8f > (const Packet8f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8h print< Packet8h > (const Packet8h &a)
 
template<typename Derived >
std::ostream & print_matrix (std::ostream &s, const Derived &_m, const IOFormat &fmt)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pround (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pround< Packet16bf > (const Packet16bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet16f pround< Packet16f > (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE Packet16h pround< Packet16h > (const Packet16h &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d pround< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4d pround< Packet4d > (const Packet4d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f pround< Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pround< Packet8bf > (const Packet8bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet8d pround< Packet8d > (const Packet8d &a)
 
template<>
EIGEN_STRONG_INLINE Packet8f pround< Packet8f > (const Packet8f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8h pround< Packet8h > (const Packet8h &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f prsqrt (const Packet4f &a)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet prsqrt (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d prsqrt (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet2f prsqrt (const Packet2f &a)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d prsqrt< Packet2d > (const Packet2d &x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d prsqrt< Packet4d > (const Packet4d &_x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f prsqrt< Packet4f > (const Packet4f &x)
 
template<>
EIGEN_STRONG_INLINE Packet8bf prsqrt< Packet8bf > (const Packet8bf &a)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f prsqrt< Packet8f > (const Packet8f &_x)
 
template<typename Scalar , typename Packet >
EIGEN_DEVICE_FUNC void pscatter (Scalar *to, const Packet &from, Index)
 
template<>
EIGEN_STRONG_INLINE void pscatter< bfloat16, Packet16bf > (bfloat16 *to, const Packet16bf &from, Index stride)
 
template<>
EIGEN_STRONG_INLINE void pscatter< bfloat16, Packet4bf > (bfloat16 *to, const Packet4bf &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< bfloat16, Packet8bf > (bfloat16 *to, const Packet8bf &from, Index stride)
 
template<>
EIGEN_STRONG_INLINE void pscatter< bfloat16, Packet8bf > (bfloat16 *to, const Packet8bf &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< bool, Packet16b > (bool *to, const Packet16b &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< double, Packet2d > (double *to, const Packet2d &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< double, Packet4d > (double *to, const Packet4d &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< double, Packet8d > (double *to, const Packet8d &from, Index stride)
 
template<>
EIGEN_STRONG_INLINE void pscatter< Eigen::half, Packet8h > (Eigen::half *to, const Packet8h &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< float, Packet16f > (float *to, const Packet16f &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< float, Packet2f > (float *to, const Packet2f &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< float, Packet4f > (float *to, const Packet4f &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< float, Packet4f > (float *to, const Packet4f &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< float, Packet8f > (float *to, const Packet8f &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< float, PacketXf > (float *to, const PacketXf &from, Index stride)
 
template<>
EIGEN_STRONG_INLINE void pscatter< half, Packet16h > (half *to, const Packet16h &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< int, Packet4i > (int *to, const Packet4i &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< int16_t, Packet4s > (int16_t *to, const Packet4s &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< int16_t, Packet8s > (int16_t *to, const Packet8s &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< int32_t, Packet2i > (int32_t *to, const Packet2i &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< int32_t, Packet4i > (int32_t *to, const Packet4i &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< int32_t, Packet4i > (int32_t *to, const Packet4i &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< int64_t, Packet2l > (int64_t *to, const Packet2l &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< int8_t, Packet16c > (int8_t *to, const Packet16c &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< int8_t, Packet4c > (int8_t *to, const Packet4c &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< int8_t, Packet8c > (int8_t *to, const Packet8c &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< numext::int32_t, PacketXi > (numext::int32_t *to, const PacketXi &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< short int, Packet8s > (short int *to, const Packet8s &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< signed char, Packet16c > (signed char *to, const Packet16c &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_DEVICE_FUNC void pscatter< std::complex< double >, Packet1cd > (std::complex< double > *to, const Packet1cd &from, Index stride __attribute__((unused)))
 
template<>
EIGEN_DEVICE_FUNC void pscatter< std::complex< double >, Packet2cd > (std::complex< double > *to, const Packet2cd &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< std::complex< double >, Packet4cd > (std::complex< double > *to, const Packet4cd &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< std::complex< float >, Packet1cf > (std::complex< float > *to, const Packet1cf &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< std::complex< float >, Packet2cf > (std::complex< float > *to, const Packet2cf &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< std::complex< float >, Packet4cf > (std::complex< float > *to, const Packet4cf &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< std::complex< float >, Packet8cf > (std::complex< float > *to, const Packet8cf &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< uint16_t, Packet4us > (uint16_t *to, const Packet4us &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< uint16_t, Packet8us > (uint16_t *to, const Packet8us &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< uint32_t, Packet2ui > (uint32_t *to, const Packet2ui &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< uint32_t, Packet4ui > (uint32_t *to, const Packet4ui &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< uint64_t, Packet2ul > (uint64_t *to, const Packet2ul &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< uint8_t, Packet16uc > (uint8_t *to, const Packet16uc &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< uint8_t, Packet4uc > (uint8_t *to, const Packet4uc &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter< uint8_t, Packet8uc > (uint8_t *to, const Packet8uc &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< unsigned char, Packet16uc > (unsigned char *to, const Packet16uc &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void pscatter< unsigned short int, Packet8us > (unsigned short int *to, const Packet8us &from, Index stride)
 
template<typename Packet >
EIGEN_DEVICE_FUNC void pscatter_size16 (__UNPACK_TYPE__(Packet) *to, const Packet &from, Index stride)
 
template<typename Packet >
EIGEN_DEVICE_FUNC void pscatter_size4 (__UNPACK_TYPE__(Packet) *to, const Packet &from, Index stride)
 
template<typename Packet >
EIGEN_DEVICE_FUNC void pscatter_size8 (__UNPACK_TYPE__(Packet) *to, const Packet &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet16f pselect (const Packet16f &mask, const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_DEVICE_FUNC Packet8d pselect (const Packet8d &mask, const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_DEVICE_FUNC Packet16b pselect (const Packet16b &mask, const Packet16b &a, const Packet16b &b)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pselect (const Packet &mask, const Packet &a, const Packet &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f pselect (const Packet4f &mask, const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8h pselect (const Packet8h &mask, const Packet8h &a, const Packet8h &b)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pselect (const Packet8bf &mask, const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16h pselect (const Packet16h &mask, const Packet16h &a, const Packet16h &b)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pselect (const Packet16bf &mask, const Packet16bf &a, const Packet16bf &b)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2f pselect (const Packet2f &mask, const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4f pselect (const Packet4f &mask, const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c pselect (const Packet8c &mask, const Packet8c &a, const Packet8c &b)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16c pselect (const Packet16c &mask, const Packet16c &a, const Packet16c &b)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc pselect (const Packet8uc &mask, const Packet8uc &a, const Packet8uc &b)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16uc pselect (const Packet16uc &mask, const Packet16uc &a, const Packet16uc &b)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s pselect (const Packet4s &mask, const Packet4s &a, const Packet4s &b)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8s pselect (const Packet8s &mask, const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us pselect (const Packet4us &mask, const Packet4us &a, const Packet4us &b)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8us pselect (const Packet8us &mask, const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2i pselect (const Packet2i &mask, const Packet2i &a, const Packet2i &b)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4i pselect (const Packet4i &mask, const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ui pselect (const Packet2ui &mask, const Packet2ui &a, const Packet2ui &b)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4ui pselect (const Packet4ui &mask, const Packet4ui &a, const Packet4ui &b)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2l pselect (const Packet2l &mask, const Packet2l &a, const Packet2l &b)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ul pselect (const Packet2ul &mask, const Packet2ul &a, const Packet2ul &b)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4bf pselect (const Packet4bf &mask, const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_DEVICE_FUNC bool pselect< bool > (const bool &cond, const bool &a, const bool &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d pselect< Packet4d > (const Packet4d &mask, const Packet4d &a, const Packet4d &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f pselect< Packet8f > (const Packet8f &mask, const Packet8f &a, const Packet8f &b)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pset1 (const typename unpacket_traits< Packet >::type &a)
 
template<>
EIGEN_STRONG_INLINE Packet16b pset1< Packet16b > (const bool &from)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pset1< Packet16bf > (const bfloat16 &from)
 
template<>
EIGEN_STRONG_INLINE Packet16c pset1< Packet16c > (const signed char &from)
 
template<>
EIGEN_STRONG_INLINE Packet16f pset1< Packet16f > (const float &from)
 
template<>
EIGEN_STRONG_INLINE Packet16h pset1< Packet16h > (const Eigen::half &from)
 
template<>
EIGEN_STRONG_INLINE Packet16i pset1< Packet16i > (const int &from)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pset1< Packet16uc > (const unsigned char &from)
 
template<>
EIGEN_STRONG_INLINE Packet1cd pset1< Packet1cd > (const std::complex< double > &from)
 
template<>
EIGEN_STRONG_INLINE Packet1cf pset1< Packet1cf > (const std::complex< float > &from)
 
template<>
EIGEN_STRONG_INLINE Packet2cd pset1< Packet2cd > (const std::complex< double > &from)
 
template<>
EIGEN_STRONG_INLINE Packet2cf pset1< Packet2cf > (const std::complex< float > &from)
 
template<>
EIGEN_STRONG_INLINE Packet2d pset1< Packet2d > (const double &from)
 
template<>
EIGEN_STRONG_INLINE Packet2f pset1< Packet2f > (const float &from)
 
template<>
EIGEN_STRONG_INLINE Packet2i pset1< Packet2i > (const int32_t &from)
 
template<>
EIGEN_STRONG_INLINE Packet2l pset1< Packet2l > (const int64_t &from)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pset1< Packet2ui > (const uint32_t &from)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pset1< Packet2ul > (const uint64_t &from)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pset1< Packet4bf > (const bfloat16 &from)
 
template<>
EIGEN_STRONG_INLINE Packet4c pset1< Packet4c > (const int8_t &from)
 
template<>
EIGEN_STRONG_INLINE Packet4cd pset1< Packet4cd > (const std::complex< double > &from)
 
template<>
EIGEN_STRONG_INLINE Packet4cf pset1< Packet4cf > (const std::complex< float > &from)
 
template<>
EIGEN_STRONG_INLINE Packet4d pset1< Packet4d > (const double &from)
 
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 Packet4i pset1< Packet4i > (const int &from)
 
template<>
EIGEN_STRONG_INLINE Packet4s pset1< Packet4s > (const int16_t &from)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pset1< Packet4uc > (const uint8_t &from)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pset1< Packet4ui > (const uint32_t &from)
 
template<>
EIGEN_STRONG_INLINE Packet4us pset1< Packet4us > (const uint16_t &from)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pset1< Packet8bf > (const bfloat16 &from)
 
template<>
EIGEN_STRONG_INLINE Packet8c pset1< Packet8c > (const int8_t &from)
 
template<>
EIGEN_STRONG_INLINE Packet8cf pset1< Packet8cf > (const std::complex< float > &from)
 
template<>
EIGEN_STRONG_INLINE Packet8d pset1< Packet8d > (const double &from)
 
template<>
EIGEN_STRONG_INLINE Packet8f pset1< Packet8f > (const float &from)
 
template<>
EIGEN_STRONG_INLINE Packet8h pset1< Packet8h > (const Eigen::half &from)
 
template<>
EIGEN_STRONG_INLINE Packet8i pset1< Packet8i > (const int &from)
 
template<>
EIGEN_STRONG_INLINE Packet8s pset1< Packet8s > (const short int &from)
 
template<>
EIGEN_STRONG_INLINE Packet8s pset1< Packet8s > (const int16_t &from)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pset1< Packet8uc > (const uint8_t &from)
 
template<>
EIGEN_STRONG_INLINE Packet8us pset1< Packet8us > (const unsigned short int &from)
 
template<>
EIGEN_STRONG_INLINE Packet8us pset1< Packet8us > (const uint16_t &from)
 
template<>
EIGEN_STRONG_INLINE PacketXf pset1< PacketXf > (const float &from)
 
template<>
EIGEN_STRONG_INLINE PacketXi pset1< PacketXi > (const numext::int32_t &from)
 
template<typename Packet >
EIGEN_STRONG_INLINE Packet pset1_size16 (const __UNPACK_TYPE__(Packet)&from)
 
template<typename Packet >
EIGEN_STRONG_INLINE Packet pset1_size4 (const __UNPACK_TYPE__(Packet)&from)
 
template<typename Packet >
EIGEN_STRONG_INLINE Packet pset1_size8 (const __UNPACK_TYPE__(Packet)&from)
 
template<typename Packet , typename BitsType >
EIGEN_DEVICE_FUNC Packet pset1frombits (BitsType a)
 
template<>
EIGEN_STRONG_INLINE Packet16f pset1frombits< Packet16f > (unsigned int from)
 
template<>
EIGEN_STRONG_INLINE Packet2d pset1frombits< Packet2d > (uint64_t from)
 
template<>
EIGEN_STRONG_INLINE Packet2f pset1frombits< Packet2f > (unsigned int from)
 
template<>
EIGEN_STRONG_INLINE Packet4d pset1frombits< Packet4d > (uint64_t from)
 
template<>
EIGEN_STRONG_INLINE Packet4f pset1frombits< Packet4f > (unsigned int from)
 
template<>
EIGEN_STRONG_INLINE Packet8d pset1frombits< Packet8d > (const numext::uint64_t from)
 
template<>
EIGEN_STRONG_INLINE Packet8f pset1frombits< Packet8f > (unsigned int from)
 
template<>
EIGEN_STRONG_INLINE PacketXf pset1frombits< PacketXf > (numext::uint32_t from)
 
template<typename CMatrix , typename CINVMatrix >
void pseudo_inverse (const CMatrix &C, CINVMatrix &CINV)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet psin (const Packet &a)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f psin< Packet16f > (const Packet16f &_x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f psin< Packet2f > (const Packet2f &x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f psin< Packet4f > (const Packet4f &_x)
 
template<>
EIGEN_STRONG_INLINE Packet8bf psin< Packet8bf > (const Packet8bf &a)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f psin< Packet8f > (const Packet8f &_x)
 
template<>
EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf psin< PacketXf > (const PacketXf &x)
 
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet psin_float (const Packet &x)
 
template<bool ComputeSine, typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet psincos_float (const Packet &_x)
 
template<bool sine>
Packet4f psincos_inner_msa_float (const Packet4f &_x)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet psinh (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f psqrt (const Packet4f &a)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet psqrt (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d psqrt (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4uc psqrt (const Packet4uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet8uc psqrt (const Packet8uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet16uc psqrt (const Packet16uc &a)
 
template<>
EIGEN_STRONG_INLINE Packet4us psqrt (const Packet4us &a)
 
template<>
EIGEN_STRONG_INLINE Packet8us psqrt (const Packet8us &a)
 
template<>
EIGEN_STRONG_INLINE Packet2ui psqrt (const Packet2ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet4ui psqrt (const Packet4ui &a)
 
template<>
EIGEN_STRONG_INLINE Packet2f psqrt (const Packet2f &a)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16b psqrt< Packet16b > (const Packet16b &x)
 
template<>
EIGEN_STRONG_INLINE Packet1cd psqrt< Packet1cd > (const Packet1cd &a)
 
template<>
EIGEN_STRONG_INLINE Packet1cf psqrt< Packet1cf > (const Packet1cf &a)
 
template<>
EIGEN_STRONG_INLINE Packet2cd psqrt< Packet2cd > (const Packet2cd &a)
 
template<>
EIGEN_STRONG_INLINE Packet2cf psqrt< Packet2cf > (const Packet2cf &a)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d psqrt< Packet2d > (const Packet2d &x)
 
template<>
EIGEN_STRONG_INLINE Packet4cd psqrt< Packet4cd > (const Packet4cd &a)
 
template<>
EIGEN_STRONG_INLINE Packet4cf psqrt< Packet4cf > (const Packet4cf &a)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d psqrt< Packet4d > (const Packet4d &_x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f psqrt< Packet4f > (const Packet4f &x)
 
template<>
EIGEN_STRONG_INLINE Packet8bf psqrt< Packet8bf > (const Packet8bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet8cf psqrt< Packet8cf > (const Packet8cf &a)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f psqrt< Packet8f > (const Packet8f &_x)
 
template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet psqrt_complex (const Packet &a)
 
template<typename Scalar , typename Packet >
EIGEN_DEVICE_FUNC void pstore (Scalar *to, const Packet &from)
 
template<typename Packet >
void pstore1 (typename unpacket_traits< Packet >::type *to, const typename unpacket_traits< Packet >::type &a)
 
template<>
EIGEN_STRONG_INLINE void pstore1< Packet16f > (float *to, const float &a)
 
template<>
EIGEN_STRONG_INLINE void pstore1< Packet16i > (int *to, const int &a)
 
template<>
EIGEN_STRONG_INLINE void pstore1< Packet2d > (double *to, const double &a)
 
template<>
EIGEN_STRONG_INLINE void pstore1< Packet4d > (double *to, const double &a)
 
template<>
EIGEN_STRONG_INLINE void pstore1< Packet4f > (float *to, const float &a)
 
template<>
EIGEN_STRONG_INLINE void pstore1< Packet8d > (double *to, const double &a)
 
template<>
EIGEN_STRONG_INLINE void pstore1< Packet8f > (float *to, const float &a)
 
template<>
EIGEN_STRONG_INLINE void pstore1< Packet8i > (int *to, const int &a)
 
template<>
EIGEN_STRONG_INLINE void pstore< bfloat16 > (bfloat16 *to, const Packet8bf &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< bfloat16 > (bfloat16 *to, const Packet16bf &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< bfloat16 > (bfloat16 *to, const Packet4bf &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< bool > (bool *to, const Packet16b &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< double > (double *to, const Packet4d &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< double > (double *to, const Packet8d &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< double > (double *to, const Packet2d &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< Eigen::half > (Eigen::half *to, const Packet8h &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< float > (float *to, const Packet4f &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< float > (float *to, const PacketXf &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< float > (float *to, const Packet8f &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< float > (float *to, const Packet16f &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< float > (float *to, const Packet2f &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< half > (Eigen::half *to, const Packet16h &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< int > (int *to, const Packet4i &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< int > (int *to, const Packet8i &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< int > (int *to, const Packet16i &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< int16_t > (int16_t *to, const Packet4s &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< int16_t > (int16_t *to, const Packet8s &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< int32_t > (int32_t *to, const Packet4i &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< int32_t > (int32_t *to, const Packet2i &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< int64_t > (int64_t *to, const Packet2l &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< int8_t > (int8_t *to, const Packet4c &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< int8_t > (int8_t *to, const Packet8c &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< int8_t > (int8_t *to, const Packet16c &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< numext::int32_t > (numext::int32_t *to, const PacketXi &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< short int > (short int *to, const Packet8s &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< signed char > (signed char *to, const Packet16c &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< std::complex< double > > (std::complex< double > *to, const Packet4cd &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< std::complex< double > > (std::complex< double > *to, const Packet2cd &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< std::complex< double > > (std::complex< double > *to, const Packet1cd &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< std::complex< float > > (std::complex< float > *to, const Packet8cf &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< std::complex< float > > (std::complex< float > *to, const Packet4cf &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< float > > (std::complex< float > *to, const Packet1cf &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< uint16_t > (uint16_t *to, const Packet4us &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< uint16_t > (uint16_t *to, const Packet8us &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< uint32_t > (uint32_t *to, const Packet2ui &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< uint32_t > (uint32_t *to, const Packet4ui &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< uint64_t > (uint64_t *to, const Packet2ul &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< uint8_t > (uint8_t *to, const Packet4uc &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< uint8_t > (uint8_t *to, const Packet8uc &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< uint8_t > (uint8_t *to, const Packet16uc &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< unsigned char > (unsigned char *to, const Packet16uc &from)
 
template<>
EIGEN_STRONG_INLINE void pstore< unsigned short int > (unsigned short int *to, const Packet8us &from)
 
template<typename Packet >
EIGEN_STRONG_INLINE void pstore_common (__UNPACK_TYPE__(Packet) *to, const Packet &from)
 
template<typename scalar , typename packet_type , int Alignment>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstoret (Eigen::TensorSycl::internal::RangeAccess< cl::sycl::access::mode::read_write, typename unpacket_traits< packet_type >::type > to, const packet_type &from)
 
template<typename Scalar , typename Packet , int Alignment>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstoret (Scalar *to, const Packet &from)
 
template<typename Scalar , typename Packet >
EIGEN_DEVICE_FUNC void pstoreu (Scalar *to, const Packet &from)
 
template<typename Scalar , typename Packet >
EIGEN_DEVICE_FUNC enable_if< unpacket_traits< Packet >::masked_store_available, void >::type pstoreu (Scalar *to, const Packet &from, typename unpacket_traits< Packet >::mask_t umask)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< bfloat16 > (bfloat16 *to, const Packet8bf &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< bfloat16 > (bfloat16 *to, const Packet16bf &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< bfloat16 > (bfloat16 *to, const Packet4bf &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< bool > (bool *to, const Packet16b &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< double > (double *to, const Packet4d &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< double > (double *to, const Packet8d &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< double > (double *to, const Packet2d &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< Eigen::half > (Eigen::half *to, const Packet8h &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< float > (float *to, const PacketXf &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< float > (float *to, const Packet8f &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< float > (float *to, const Packet8f &from, uint8_t umask)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< float > (float *to, const Packet16f &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< float > (float *to, const Packet16f &from, uint16_t umask)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< float > (float *to, const Packet4f &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< float > (float *to, const Packet2f &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< half > (Eigen::half *to, const Packet16h &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< int > (int *to, const Packet8i &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< int > (int *to, const Packet16i &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< int > (int *to, const Packet4i &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< int16_t > (int16_t *to, const Packet4s &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< int16_t > (int16_t *to, const Packet8s &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< int32_t > (int32_t *to, const Packet4i &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< int32_t > (int32_t *to, const Packet2i &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< int64_t > (int64_t *to, const Packet2l &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< int8_t > (int8_t *to, const Packet4c &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< int8_t > (int8_t *to, const Packet8c &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< int8_t > (int8_t *to, const Packet16c &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< numext::int32_t > (numext::int32_t *to, const PacketXi &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< short int > (short int *to, const Packet8s &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< signed char > (signed char *to, const Packet16c &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< std::complex< double > > (std::complex< double > *to, const Packet4cd &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< std::complex< double > > (std::complex< double > *to, const Packet2cd &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< std::complex< double > > (std::complex< double > *to, const Packet1cd &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< std::complex< float > > (std::complex< float > *to, const Packet8cf &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< std::complex< float > > (std::complex< float > *to, const Packet4cf &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< float > > (std::complex< float > *to, const Packet1cf &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< uint16_t > (uint16_t *to, const Packet4us &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< uint16_t > (uint16_t *to, const Packet8us &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< uint32_t > (uint32_t *to, const Packet2ui &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< uint32_t > (uint32_t *to, const Packet4ui &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< uint64_t > (uint64_t *to, const Packet2ul &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< uint8_t > (uint8_t *to, const Packet4uc &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< uint8_t > (uint8_t *to, const Packet8uc &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< uint8_t > (uint8_t *to, const Packet16uc &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< unsigned char > (unsigned char *to, const Packet16uc &from)
 
template<>
EIGEN_STRONG_INLINE void pstoreu< unsigned short int > (unsigned short int *to, const Packet8us &from)
 
template<typename Packet >
EIGEN_STRONG_INLINE void pstoreu_common (__UNPACK_TYPE__(Packet) *to, const Packet &from)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet psub (const Packet &a, const Packet &b)
 
template<>
EIGEN_STRONG_INLINE Packet16b psub< Packet16b > (const Packet16b &a, const Packet16b &b)
 
template<>
EIGEN_STRONG_INLINE Packet16bf psub< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c psub< Packet16c > (const Packet16c &a, const Packet16c &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f psub< Packet16f > (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet16h psub< Packet16h > (const Packet16h &a, const Packet16h &b)
 
template<>
EIGEN_STRONG_INLINE Packet16i psub< Packet16i > (const Packet16i &a, const Packet16i &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc psub< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet1cd psub< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet1cf psub< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cd psub< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cf psub< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d psub< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f psub< Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2i psub< Packet2i > (const Packet2i &a, const Packet2i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2l psub< Packet2l > (const Packet2l &a, const Packet2l &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ui psub< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ul psub< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf psub< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4c psub< Packet4c > (const Packet4c &a, const Packet4c &b)
 
template<>
EIGEN_STRONG_INLINE Packet4cd psub< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet4cf psub< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d psub< Packet4d > (const Packet4d &a, const Packet4d &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 Packet4s psub< Packet4s > (const Packet4s &a, const Packet4s &b)
 
template<>
EIGEN_STRONG_INLINE Packet4uc psub< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet4ui psub< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet4us psub< Packet4us > (const Packet4us &a, const Packet4us &b)
 
template<>
EIGEN_STRONG_INLINE Packet8bf psub< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8c psub< Packet8c > (const Packet8c &a, const Packet8c &b)
 
template<>
EIGEN_STRONG_INLINE Packet8cf psub< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d psub< Packet8d > (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f psub< Packet8f > (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8h psub< Packet8h > (const Packet8h &a, const Packet8h &b)
 
template<>
EIGEN_STRONG_INLINE Packet8i psub< Packet8i > (const Packet8i &a, const Packet8i &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s psub< Packet8s > (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet8uc psub< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us psub< Packet8us > (const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_STRONG_INLINE PacketXf psub< PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<>
EIGEN_STRONG_INLINE PacketXi psub< PacketXi > (const PacketXi &a, const PacketXi &b)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet ptan (const Packet &a)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet ptanh (const Packet &a)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f ptanh< Packet16f > (const Packet16f &_x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f ptanh< Packet2f > (const Packet2f &x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f ptanh< Packet4f > (const Packet4f &x)
 
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f ptanh< Packet8f > (const Packet8f &_x)
 
template<>
EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf ptanh< PacketXf > (const PacketXf &x)
 
template<typename T >
EIGEN_DEVICE_FUNC void ptranpose_common (PacketBlock< T, 4 > &kernel)
 
EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet2cf, 2 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet4cf, 4 > &kernel)
 
template<int N>
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< PacketXi, N > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet2cd, 2 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet8cf, 4 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet1cf, 1 > &)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet8cf, 8 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet4cd, 4 > &kernel)
 
EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet1cd, 2 > &kernel)
 
template<int N>
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< PacketXf, N > &kernel)
 
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<typename Packet >
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet, 1 > &)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet16f, 16 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet16b, 4 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet2d, 2 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet16b, 16 > &kernel)
 
EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet8h, 8 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet16f, 4 > &kernel)
 
EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet8h, 4 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet8d, 4 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet8d, 8 > &kernel)
 
EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet16h, 16 > &kernel)
 
EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet16h, 8 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet4f, 4 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet4i, 4 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet8s, 4 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet8us, 4 > &kernel)
 
EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet16h, 4 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet8bf, 4 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet16c, 4 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet16uc, 4 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet8s, 8 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet8us, 8 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet8bf, 8 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet16c, 16 > &kernel)
 
EIGEN_DEVICE_FUNC void ptranspose (PacketBlock< Packet16uc, 16 > &kernel)
 
EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet16bf, 16 > &kernel)
 
EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet16bf, 4 > &kernel)
 
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet2f, 2 > &kernel)
 
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet4c, 4 > &kernel)
 
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet8c, 8 > &kernel)
 
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet8c, 4 > &kernel)
 
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet16c, 8 > &kernel)
 
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet4uc, 4 > &kernel)
 
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet8uc, 8 > &kernel)
 
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet8uc, 4 > &kernel)
 
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet16uc, 8 > &kernel)
 
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet4s, 4 > &kernel)
 
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet4us, 4 > &kernel)
 
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet2i, 2 > &kernel)
 
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet2ui, 2 > &kernel)
 
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet4ui, 4 > &kernel)
 
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet2l, 2 > &kernel)
 
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet2ul, 2 > &kernel)
 
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose (PacketBlock< Packet4bf, 4 > &kernel)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet ptrue (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE Packet8h ptrue (const Packet8h &a)
 
template<>
EIGEN_STRONG_INLINE Packet8bf ptrue (const Packet8bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet16h ptrue (const Packet16h &a)
 
template<>
EIGEN_STRONG_INLINE Packet16bf ptrue (const Packet16bf &a)
 
template<>
EIGEN_STRONG_INLINE Packet16b ptrue< Packet16b > (const Packet16b &a)
 
template<>
EIGEN_STRONG_INLINE Packet16f ptrue< Packet16f > (const Packet16f &a)
 
template<>
EIGEN_STRONG_INLINE Packet16i ptrue< Packet16i > (const Packet16i &)
 
template<>
EIGEN_STRONG_INLINE Packet1cd ptrue< Packet1cd > (const Packet1cd &a)
 
template<>
EIGEN_STRONG_INLINE Packet2cd ptrue< Packet2cd > (const Packet2cd &a)
 
template<>
EIGEN_STRONG_INLINE Packet2cf ptrue< Packet2cf > (const Packet2cf &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d ptrue< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4cd ptrue< Packet4cd > (const Packet4cd &a)
 
template<>
EIGEN_STRONG_INLINE Packet4cf ptrue< Packet4cf > (const Packet4cf &a)
 
template<>
EIGEN_STRONG_INLINE Packet4d ptrue< Packet4d > (const Packet4d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f ptrue< Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i ptrue< Packet4i > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet8cf ptrue< Packet8cf > (const Packet8cf &a)
 
template<>
EIGEN_STRONG_INLINE Packet8d ptrue< Packet8d > (const Packet8d &a)
 
template<>
EIGEN_STRONG_INLINE Packet8f ptrue< Packet8f > (const Packet8f &a)
 
template<>
EIGEN_STRONG_INLINE Packet8i ptrue< Packet8i > (const Packet8i &a)
 
template<>
EIGEN_STRONG_INLINE PacketXf ptrue< PacketXf > (const PacketXf &)
 
template<>
EIGEN_STRONG_INLINE PacketXi ptrue< PacketXi > (const PacketXi &)
 
EIGEN_STRONG_INLINE void punpackp (Packet4f *vecs)
 
template<typename Scalar >
void putMarketHeader (std::string &header, int sym)
 
template<typename Scalar , typename StorageIndex >
void PutMatrixElt (Scalar value, StorageIndex row, StorageIndex col, std::ofstream &out)
 
template<typename Scalar , typename StorageIndex >
void PutMatrixElt (std::complex< Scalar > value, StorageIndex row, StorageIndex col, std::ofstream &out)
 
template<typename Scalar >
void putVectorElt (Scalar value, std::ofstream &out)
 
template<typename Scalar >
void putVectorElt (std::complex< Scalar > value, std::ofstream &out)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pxor (const Packet &a, const Packet &b)
 
template<>
EIGEN_STRONG_INLINE Packet8h pxor (const Packet8h &a, const Packet8h &b)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pxor (const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16h pxor (const Packet16h &a, const Packet16h &b)
 
template<>
EIGEN_STRONG_INLINE Packet16bf pxor (const Packet16bf &a, const Packet16bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4bf pxor (const Packet4bf &a, const Packet4bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet16b pxor< Packet16b > (const Packet16b &a, const Packet16b &b)
 
template<>
EIGEN_STRONG_INLINE Packet16c pxor< Packet16c > (const Packet16c &a, const Packet16c &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f pxor< Packet16f > (const Packet16f &a, const Packet16f &b)
 
template<>
EIGEN_STRONG_INLINE Packet16i pxor< Packet16i > (const Packet16i &a, const Packet16i &b)
 
template<>
EIGEN_STRONG_INLINE Packet16uc pxor< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet1cd pxor< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet1cf pxor< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cd pxor< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet2cf pxor< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d pxor< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet2f pxor< Packet2f > (const Packet2f &a, const Packet2f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2i pxor< Packet2i > (const Packet2i &a, const Packet2i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2l pxor< Packet2l > (const Packet2l &a, const Packet2l &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ui pxor< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet2ul pxor< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
 
template<>
EIGEN_STRONG_INLINE Packet4c pxor< Packet4c > (const Packet4c &a, const Packet4c &b)
 
template<>
EIGEN_STRONG_INLINE Packet4cd pxor< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
 
template<>
EIGEN_STRONG_INLINE Packet4cf pxor< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet4d pxor< Packet4d > (const Packet4d &a, const Packet4d &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 Packet4s pxor< Packet4s > (const Packet4s &a, const Packet4s &b)
 
template<>
EIGEN_STRONG_INLINE Packet4uc pxor< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet4ui pxor< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
 
template<>
EIGEN_STRONG_INLINE Packet4us pxor< Packet4us > (const Packet4us &a, const Packet4us &b)
 
template<>
EIGEN_STRONG_INLINE Packet8bf pxor< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8c pxor< Packet8c > (const Packet8c &a, const Packet8c &b)
 
template<>
EIGEN_STRONG_INLINE Packet8cf pxor< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
 
template<>
EIGEN_STRONG_INLINE Packet8d pxor< Packet8d > (const Packet8d &a, const Packet8d &b)
 
template<>
EIGEN_STRONG_INLINE Packet8f pxor< Packet8f > (const Packet8f &a, const Packet8f &b)
 
template<>
EIGEN_STRONG_INLINE Packet8i pxor< Packet8i > (const Packet8i &a, const Packet8i &b)
 
template<>
EIGEN_STRONG_INLINE Packet8s pxor< Packet8s > (const Packet8s &a, const Packet8s &b)
 
template<>
EIGEN_STRONG_INLINE Packet8uc pxor< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
 
template<>
EIGEN_STRONG_INLINE Packet8us pxor< Packet8us > (const Packet8us &a, const Packet8us &b)
 
template<>
EIGEN_STRONG_INLINE PacketXf pxor< PacketXf > (const PacketXf &a, const PacketXf &b)
 
template<>
EIGEN_STRONG_INLINE PacketXi pxor< PacketXi > (const PacketXi &a, const PacketXi &b)
 
template<>
EIGEN_STRONG_INLINE Packet16f pzero (const Packet16f &)
 
template<>
EIGEN_STRONG_INLINE Packet8d pzero (const Packet8d &)
 
template<>
EIGEN_STRONG_INLINE Packet16i pzero (const Packet16i &)
 
template<>
EIGEN_STRONG_INLINE Packet8f pzero (const Packet8f &)
 
template<>
EIGEN_STRONG_INLINE Packet4d pzero (const Packet4d &)
 
template<>
EIGEN_STRONG_INLINE Packet8i pzero (const Packet8i &)
 
template<>
EIGEN_STRONG_INLINE Packet4f pzero (const Packet4f &)
 
template<>
EIGEN_STRONG_INLINE Packet2d pzero (const Packet2d &)
 
template<>
EIGEN_STRONG_INLINE Packet4i pzero (const Packet4i &)
 
template<typename Packet >
EIGEN_DEVICE_FUNC Packet pzero (const Packet &a)
 
template<>
EIGEN_STRONG_INLINE PacketXi pzero< PacketXi > (const PacketXi &)
 
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pzeta (const Packet &x, const Packet &q)
 
template<typename Scalar >
void qrsolv (Matrix< Scalar, Dynamic, Dynamic > &s, const VectorXi &ipvt, const Matrix< Scalar, Dynamic, 1 > &diag, const Matrix< Scalar, Dynamic, 1 > &qtb, Matrix< Scalar, Dynamic, 1 > &x, Matrix< Scalar, Dynamic, 1 > &sdiag)
 
void queryCacheSizes (int &l1, int &l2, int &l3)
 
int queryL1CacheSize ()
 
int queryTopLevelCacheSize ()
 
template<typename VectorV , typename VectorI >
Index QuickSplit (VectorV &row, VectorI &ind, Index ncut)
 
template<typename Scalar >
void r1mpyq (DenseIndex m, DenseIndex n, Scalar *a, const std::vector< JacobiRotation< Scalar > > &v_givens, const std::vector< JacobiRotation< Scalar > > &w_givens)
 
template<typename Scalar >
void r1updt (Matrix< Scalar, Dynamic, Dynamic > &s, const Matrix< Scalar, Dynamic, 1 > &u, std::vector< JacobiRotation< Scalar > > &v_givens, std::vector< JacobiRotation< Scalar > > &w_givens, Matrix< Scalar, Dynamic, 1 > &v, Matrix< Scalar, Dynamic, 1 > &w, bool *sing)
 
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T RandomToTypeNormal (uint64_t *state, uint64_t stream)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex< double > RandomToTypeNormal< std::complex< double > > (uint64_t *state, uint64_t stream)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex< float > RandomToTypeNormal< std::complex< float > > (uint64_t *state, uint64_t stream)
 
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T RandomToTypeUniform (uint64_t *state, uint64_t stream)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double RandomToTypeUniform< double > (uint64_t *state, uint64_t stream)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::bfloat16 RandomToTypeUniform< Eigen::bfloat16 > (uint64_t *state, uint64_t stream)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half RandomToTypeUniform< Eigen::half > (uint64_t *state, uint64_t stream)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float RandomToTypeUniform< float > (uint64_t *state, uint64_t stream)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex< double > RandomToTypeUniform< std::complex< double > > (uint64_t *state, uint64_t stream)
 
template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex< float > RandomToTypeUniform< std::complex< float > > (uint64_t *state, uint64_t stream)
 
template<typename Decomposition >
Decomposition::RealScalar rcond_estimate_helper (typename Decomposition::RealScalar matrix_norm, const Decomposition &dec)
 Reciprocal condition number estimator. More...
 
template<typename Decomposition >
Decomposition::RealScalar rcond_invmatrix_L1_norm_estimate (const Decomposition &dec)
 
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 Self >
EIGEN_STRONG_INLINE void ReducePacket (Self &self, Index offset, typename Self::CoeffReturnType *data)
 
template<typename Self >
EIGEN_STRONG_INLINE void ReduceScalar (Self &self, Index offset, typename Self::CoeffReturnType *data)
 
template<int n, typename t >
constexpr array< t, nrepeat (t v)
 
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 T >
const Treturn_ptr ()
 
template<typename Scalar >
void rwupdt (Matrix< Scalar, Dynamic, Dynamic > &r, const Matrix< Scalar, Dynamic, 1 > &w, Matrix< Scalar, Dynamic, 1 > &b, Scalar alpha)
 
template<typename InputIterator , typename SparseMatrixType , typename DupFunctor >
void set_from_triplets (const InputIterator &begin, const InputIterator &end, SparseMatrixType &mat, DupFunctor dup_func)
 
EIGEN_STRONG_INLINE Packet4f shuffle1 (const Packet4f &m, int mask)
 
template<bool interleave>
EIGEN_STRONG_INLINE Packet4f shuffle2 (const Packet4f &m, const Packet4f &n, int mask)
 
template<>
EIGEN_STRONG_INLINE Packet4f shuffle2< true > (const Packet4f &m, const Packet4f &n, int mask)
 
template<typename T >
EIGEN_CONSTEXPR Index size (const T &x)
 
template<typename T , std::size_t N>
EIGEN_CONSTEXPR Index size (const T(&) [N])
 
template<typename Lhs , typename Rhs , typename Dest >
EIGEN_DONT_INLINE void skyline_col_major_time_dense_product (const Lhs &lhs, const Rhs &rhs, Dest &dst)
 
template<typename Lhs , typename Rhs , typename Dest >
EIGEN_DONT_INLINE void skyline_row_major_time_dense_product (const Lhs &lhs, const Rhs &rhs, Dest &dst)
 
template<typename T >
EIGEN_DEVICE_FUNC void smart_copy (const T *start, const T *end, T *target)
 
template<typename T >
void smart_memmove (const T *start, const T *end, T *target)
 
template<typename T >
EIGEN_DEVICE_FUNC Tsmart_move (T *start, T *end, T *target)
 
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 VectorType , typename IndexType >
void sortWithPermutation (VectorType &vec, IndexType &perm, typename IndexType::Scalar &ncut)
 Computes a permutation vector to have a sorted sequence. More...
 
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<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 Lhs , typename Rhs , typename ResultType >
static void sparse_sparse_to_dense_product_impl (const Lhs &lhs, const Rhs &rhs, ResultType &res)
 
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 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)
 
template<typename VectorType >
VectorType::RealScalar stable_norm_impl (const VectorType &vec, typename enable_if< VectorType::IsVectorAtCompileTime >::type *=0)
 
template<typename MatrixType >
MatrixType::RealScalar stable_norm_impl (const MatrixType &mat, typename enable_if<!MatrixType::IsVectorAtCompileTime >::type *=0)
 
template<typename VectorType , typename RealScalar >
void stable_norm_impl_inner_step (const VectorType &vec, RealScalar &ssq, RealScalar &scale, RealScalar &invScale)
 
template<typename ExpressionType , typename Scalar >
void stable_norm_kernel (const ExpressionType &bl, Scalar &ssq, Scalar &scale, Scalar &invScale)
 
template<typename Scalar >
Scalar stem_function_cos (Scalar x, int n)
 Cosine (and its derivatives). More...
 
template<typename Scalar >
Scalar stem_function_cosh (Scalar x, int n)
 Hyperbolic cosine (and its derivatives). More...
 
template<typename Scalar >
Scalar stem_function_exp (Scalar x, int)
 The exponential function (and its derivatives). More...
 
template<typename Scalar >
Scalar stem_function_sin (Scalar x, int n)
 Sine (and its derivatives). More...
 
template<typename Scalar >
Scalar stem_function_sinh (Scalar x, int n)
 Hyperbolic sine (and its derivatives). More...
 
template<typename DataMapper , typename Index , typename Packet , const Index accCols>
EIGEN_ALWAYS_INLINE void storeAccumulator (Index i, Index j, const DataMapper &data, const Packet &alpha, __vector_quad *acc)
 
template<typename Scalar , typename Packet , typename Index >
EIGEN_ALWAYS_INLINE void storeBlock (Scalar *to, PacketBlock< Packet, 4 > &block)
 
template<typename Scalar , typename Packet , typename Index >
EIGEN_ALWAYS_INLINE void storeBlock (Scalar *to, PacketBlock< Packet, 2 > &block)
 
template<typename DataMapper , typename Index , typename Packet , typename Packetc , const Index accColsC, int N>
EIGEN_ALWAYS_INLINE void storeComplexAccumulator (Index i, Index j, const DataMapper &data, const Packet &alphaReal, const Packet &alphaImag, __vector_quad *accReal, __vector_quad *accImag)
 
template<int Layout, typename IndexType , int NumDims>
EIGEN_ALWAYS_INLINE DSizes< IndexType, NumDims > strides (const DSizes< IndexType, NumDims > &dimensions)
 
template<int Layout, typename IndexType , size_t NumDims>
EIGEN_ALWAYS_INLINE DSizes< IndexType, NumDims > strides (const Eigen::array< IndexType, NumDims > &dimensions)
 
template<int Layout, std::ptrdiff_t... Indices>
EIGEN_STRONG_INLINE DSizes< std::ptrdiff_t, sizeof...(Indices)> strides (const Sizes< Indices... > &sizes)
 
template<typename T >
void swap (scoped_array< T > &a, scoped_array< T > &b)
 
template<typename Scalar , typename Index , int StorageOrder>
EIGEN_STRONG_INLINE void symm_pack_complex_lhs_helper (std::complex< Scalar > *blockA, const std::complex< Scalar > *_lhs, Index lhsStride, Index cols, Index rows)
 
template<typename Scalar , typename Index , int StorageOrder, int N>
EIGEN_STRONG_INLINE void symm_pack_complex_rhs_helper (std::complex< Scalar > *blockB, const std::complex< Scalar > *_rhs, Index rhsStride, Index rows, Index cols, Index k2)
 
template<typename Scalar , typename Index , int StorageOrder>
EIGEN_STRONG_INLINE void symm_pack_lhs_helper (Scalar *blockA, const Scalar *_lhs, Index lhsStride, Index cols, Index rows)
 
template<typename Scalar , typename Index , int StorageOrder, int N>
EIGEN_STRONG_INLINE void symm_pack_rhs_helper (Scalar *blockB, const Scalar *_rhs, Index rhsStride, Index rows, Index cols, Index k2)
 
template<typename Index , std::size_t N, int... ii, int... jj>
static constexpr std::array< Index, Ntensor_static_symgroup_index_permute (std::array< Index, N > idx, internal::numeric_list< int, ii... >, internal::numeric_list< int, jj... >)
 
template<typename Index , int... ii>
static std::vector< Indextensor_static_symgroup_index_permute (std::vector< Index > idx, internal::numeric_list< int, ii... >)
 
EIGEN_DEVICE_FUNC void throw_std_bad_alloc ()
 
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 IndexVector >
void treePostorder (typename IndexVector::Scalar n, IndexVector &parent, IndexVector &post)
 Post order a tree. More...
 
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 >
EIGEN_DEVICE_FUNC void tridiagonalization_inplace (MatrixType &matA, CoeffVectorType &hCoeffs)
 
template<typename MatrixType , typename DiagonalType , typename SubDiagonalType , typename CoeffVectorType >
EIGEN_DEVICE_FUNC void tridiagonalization_inplace (MatrixType &mat, DiagonalType &diag, SubDiagonalType &subdiag, CoeffVectorType &hcoeffs, bool extractQ)
 Performs a full tridiagonalization in place. More...
 
float trig_reduce_huge (float xf, int *quadrant)
 
template<typename Packet >
EIGEN_STRONG_INLINE void twoprod (const Packet &x, const Packet &y, Packet &p_hi, Packet &p_lo)
 
template<typename Packet >
EIGEN_STRONG_INLINE void twoprod (const Packet &x_hi, const Packet &x_lo, const Packet &y, Packet &p_hi, Packet &p_lo)
 
template<typename Packet >
EIGEN_STRONG_INLINE void twoprod (const Packet &x_hi, const Packet &x_lo, const Packet &y_hi, const Packet &y_lo, Packet &p_hi, Packet &p_lo)
 
template<typename Packet >
EIGEN_STRONG_INLINE void twosum (const Packet &x_hi, const Packet &x_lo, const Packet &y_hi, const Packet &y_lo, Packet &s_hi, Packet &s_lo)
 
template<typename 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 MatrixType >
void upperbidiagonalization_inplace_unblocked (MatrixType &mat, typename MatrixType::RealScalar *diagonal, typename MatrixType::RealScalar *upper_diagonal, typename MatrixType::Scalar *tempData=0)
 
template<typename Index >
bool useSpecificBlockingSizes (Index &k, Index &m, Index &n)
 
EIGEN_STRONG_INLINE Packet2d vec2d_unpackhi (const Packet2d &a, const Packet2d &b)
 
EIGEN_STRONG_INLINE Packet2d vec2d_unpacklo (const Packet2d &a, const Packet2d &b)
 
EIGEN_STRONG_INLINE Packet4f vec4f_movehl (const Packet4f &a, const Packet4f &b)
 
EIGEN_STRONG_INLINE Packet4f vec4f_movelh (const Packet4f &a, const Packet4f &b)
 
EIGEN_STRONG_INLINE Packet4f vec4f_swizzle1 (const Packet4f &a, int p, int q, int r, int s)
 
EIGEN_STRONG_INLINE Packet4f vec4f_swizzle2 (const Packet4f &a, const Packet4f &b, int p, int q, int r, int s)
 
EIGEN_STRONG_INLINE Packet4f vec4f_unpackhi (const Packet4f &a, const Packet4f &b)
 
EIGEN_STRONG_INLINE Packet4f vec4f_unpacklo (const Packet4f &a, const Packet4f &b)
 
template<int element>
EIGEN_STRONG_INLINE Packet4f vec_splat_packet4f (const Packet4f &from)
 
template<typename Packet >
EIGEN_STRONG_INLINE void veltkamp_splitting (const Packet &x, Packet &x_hi, Packet &x_lo)
 

Variables

template<typename... Ts>
EIGEN_DEVICE_FUNC constexprdecltype(reduce< product_op, Ts... >::run((*((Ts *) 0))...)) EIGEN_STRONG_INLIN arg_prod )(Ts... ts)
 
template<typename... Ts>
constexprdecltype(reduce< sum_op, Ts... >::run((*((Ts *) 0))...)) EIGEN_STRONG_INLIN arg_sum )(Ts... ts)
 
const std::ptrdiff_t defaultL1CacheSize = EIGEN_SET_DEFAULT_L1_CACHE_SIZE(16*1024)
 
const std::ptrdiff_t defaultL2CacheSize = EIGEN_SET_DEFAULT_L2_CACHE_SIZE(512*1024)
 
const std::ptrdiff_t defaultL3CacheSize = EIGEN_SET_DEFAULT_L3_CACHE_SIZE(512*1024)
 
static const int kLeafSize = 1024
 
static const Packet2l mask21 = { -1, 0 }
 
static const Packet4i mask41 = { -1, 0, 0, 0 }
 
static const Packet4i mask42 = { -1, -1, 0, 0 }
 
static const Packet4i mask43 = { -1, -1, -1, 0 }
 
static const float matrix_function_separation = 0.1f
 Maximum distance allowed between eigenvalues to be considered "close". More...
 
static Packet16c p16c_COUNTDOWN
 
static Packet16uc p16uc_COMPLEX32_REV = vec_sld(p16uc_REVERSE32, p16uc_REVERSE32, 8)
 
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 Packet16uc p16uc_COMPLEX32_REV2 = vec_sld(p16uc_FORWARD, p16uc_FORWARD, 8)
 
static Packet16uc p16uc_COUNTDOWN
 
static const Packet16uc p16uc_DUPLICATE16_EVEN = { 0,1 ,0,1, 4,5, 4,5, 8,9, 8,9, 12,13, 12,13 }
 
static Packet16uc p16uc_DUPLICATE16_HI = { 0,1,0,1, 2,3,2,3, 4,5,4,5, 6,7,6,7 }
 
static const Packet16uc p16uc_DUPLICATE16_ODD = { 2,3 ,2,3, 6,7, 6,7, 10,11, 10,11, 14,15, 14,15 }
 
static Packet16uc p16uc_DUPLICATE32_HI = { 0,1,2,3, 0,1,2,3, 4,5,6,7, 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_DUPLICATE8_HI = { 0,0, 1,1, 2,2, 3,3, 4,4, 5,5, 6,6, 7,7 }
 
static Packet16uc p16uc_FORWARD = p16uc_REVERSE32
 
static Packet16uc p16uc_FORWARD = { 0,1,2,3, 4,5,6,7, 8,9,10,11, 12,13,14,15 }
 
static const Packet16uc p16uc_GETIMAG32
 
static const Packet16uc p16uc_GETIMAG64
 
static const Packet16uc p16uc_GETREAL32
 
static const Packet16uc p16uc_GETREAL64
 
static Packet16uc p16uc_HALF64_0_16 = vec_sld(vec_splat((Packet16uc) vec_abs(p4i_MINUS16), 0), (Packet16uc)p4i_ZERO, 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_PSET32_WEVEN = vec_sld(p16uc_DUPLICATE32_HI, (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 3), 8)
 
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_WODD = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 0), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 2), 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_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_PSET64_LO = (Packet16uc) vec_mergel((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN)
 
static Packet16uc p16uc_QUADRUPLICATE16_HI = { 0,1,0,1,0,1,0,1, 2,3,2,3,2,3,2,3 }
 
static Packet16uc p16uc_REVERSE16 = { 14,15, 12,13, 10,11, 8,9, 6,7, 4,5, 2,3, 0,1 }
 
static Packet16uc p16uc_REVERSE32 = { 12,13,14,15, 8,9,10,11, 4,5,6,7, 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_REVERSE64 = { 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 }
 
static Packet16uc p16uc_REVERSE64 = { 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 }
 
static Packet16uc p16uc_REVERSE8 = { 15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0 }
 
static const Packet16uc p16uc_SETCOMPLEX32_FIRST
 
static const Packet16uc p16uc_SETCOMPLEX32_SECOND
 
static const Packet16uc p16uc_SETCOMPLEX64_FIRST
 
static const Packet16uc p16uc_SETCOMPLEX64_SECOND
 
static Packet16uc p16uc_TRANSPOSE64_HI = p16uc_PSET64_HI + p16uc_HALF64_0_16
 
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 = p16uc_PSET64_LO + p16uc_HALF64_0_16
 
static Packet16uc p16uc_TRANSPOSE64_LO = { 8,9,10,11, 12,13,14,15, 24,25,26,27, 28,29,30,31}
 
static Packet2d p2d_COUNTDOWN = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet16uc>(p2d_ZERO), reinterpret_cast<Packet16uc>(p2d_ONE), 8))
 
static Packet2d p2d_ONE = { 1.0, 1.0 }
 
static Packet2d p2d_ZERO_
 
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 Packet4f p4f_COUNTDOWN = { 0.0, 1.0, 2.0, 3.0 }
 
static Packet4f p4f_COUNTDOWN = { 0.0, 1.0, 2.0, 3.0 }
 
static Packet4f p4f_MZERO = (Packet4f) vec_sl((Packet4ui)p4i_MINUS1, (Packet4ui)p4i_MINUS1)
 
static Packet4f p4f_MZERO = { 0x80000000, 0x80000000, 0x80000000, 0x80000000}
 
static Packet4f p4f_ONE = vec_ctf(p4i_ONE, 0)
 
static Packet4i p4i_COUNTDOWN = { 0, 1, 2, 3 }
 
static Packet4i p4i_COUNTDOWN = { 0, 1, 2, 3 }
 
static Packet4ui p4ui_CONJ_XOR = vec_mergeh((Packet4ui)p4i_ZERO, (Packet4ui)p4f_MZERO)
 
static Packet4ui p4ui_CONJ_XOR = { 0x00000000, 0x80000000, 0x00000000, 0x80000000 }
 
static Packet8s p8s_COUNTDOWN = { 0, 1, 2, 3, 4, 5, 6, 7 }
 
static Packet8us p8us_COUNTDOWN = { 0, 1, 2, 3, 4, 5, 6, 7 }
 
const Scalary
 

Typedef Documentation

◆ __attribute__

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

Definition at line 33 of file SVE/PacketMath.h.

◆ IntPtr

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

Definition at line 91 of file Meta.h.

◆ Packet16b

Definition at line 47 of file SSE/PacketMath.h.

◆ Packet16bf

Definition at line 35 of file AVX512/PacketMath.h.

◆ Packet16c

typedef int8x16_t Eigen::internal::Packet16c

Definition at line 36 of file AltiVec/PacketMath.h.

◆ Packet16f

Definition at line 31 of file AVX512/PacketMath.h.

◆ Packet16h

Definition at line 34 of file AVX512/PacketMath.h.

◆ Packet16i

typedef __m512i Eigen::internal::Packet16i

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

◆ Packet16uc

typedef __vector unsigned char Eigen::internal::Packet16uc

Definition at line 37 of file AltiVec/PacketMath.h.

◆ Packet2d

typedef __vector double Eigen::internal::Packet2d

Definition at line 820 of file MSA/PacketMath.h.

◆ Packet2f

typedef float32x2_t Eigen::internal::Packet2f

Definition at line 62 of file NEON/PacketMath.h.

◆ Packet2i

typedef int32x2_t Eigen::internal::Packet2i

Definition at line 74 of file NEON/PacketMath.h.

◆ Packet2l

typedef __vector long long Eigen::internal::Packet2l

Definition at line 821 of file MSA/PacketMath.h.

◆ Packet2ui

typedef uint32x2_t Eigen::internal::Packet2ui

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

◆ Packet2ul

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

Definition at line 822 of file MSA/PacketMath.h.

◆ Packet4bf

Definition at line 3317 of file NEON/PacketMath.h.

◆ Packet4bi

typedef __vector __bool int Eigen::internal::Packet4bi

Definition at line 33 of file AltiVec/PacketMath.h.

◆ Packet4c

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

◆ Packet4d

typedef __m256d Eigen::internal::Packet4d

Definition at line 33 of file AVX/PacketMath.h.

◆ Packet4f

typedef __vector float Eigen::internal::Packet4f

Definition at line 30 of file AltiVec/PacketMath.h.

◆ Packet4i

typedef __vector int Eigen::internal::Packet4i

Definition at line 31 of file AltiVec/PacketMath.h.

◆ Packet4s

typedef int16x4_t Eigen::internal::Packet4s

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

◆ Packet4uc

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

◆ Packet4ui

typedef __vector unsigned int Eigen::internal::Packet4ui

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

◆ Packet4us

typedef uint16x4_t Eigen::internal::Packet4us

Definition at line 72 of file NEON/PacketMath.h.

◆ Packet8bf

Definition at line 38 of file AltiVec/PacketMath.h.

◆ Packet8c

typedef int8x8_t Eigen::internal::Packet8c

Definition at line 65 of file NEON/PacketMath.h.

◆ Packet8d

typedef __m512d Eigen::internal::Packet8d

Definition at line 33 of file AVX512/PacketMath.h.

◆ Packet8f

typedef __m256 Eigen::internal::Packet8f

Definition at line 31 of file AVX/PacketMath.h.

◆ Packet8h

Definition at line 34 of file AVX/PacketMath.h.

◆ Packet8i

typedef __vector short int Eigen::internal::Packet8i

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

◆ Packet8s

typedef int16x8_t Eigen::internal::Packet8s

Definition at line 34 of file AltiVec/PacketMath.h.

◆ Packet8uc

typedef uint8x8_t Eigen::internal::Packet8uc

Definition at line 68 of file NEON/PacketMath.h.

◆ Packet8us

typedef uint16x8_t Eigen::internal::Packet8us

Definition at line 35 of file AltiVec/PacketMath.h.

◆ SsePrefetchPtrType

Definition at line 864 of file SSE/PacketMath.h.

◆ UIntPtr

Definition at line 92 of file Meta.h.

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 

Definition at line 837 of file Eigen/src/Core/MathFunctions.h.

◆ anonymous enum

anonymous enum
Enumerator
SDP_AsScalarProduct 
SDP_AsCwiseProduct 

Definition at line 29 of file SparseDiagonalProduct.h.

◆ anonymous enum

anonymous enum
Enumerator
SVA_RuntimeSwitch 
SVA_Inner 
SVA_Outer 

Definition at line 49 of file SparseVector.h.

◆ anonymous enum

anonymous enum
Enumerator
LUNoMarker 

Definition at line 37 of file SparseLU_Memory.h.

◆ anonymous enum

anonymous enum
Enumerator
emptyIdxLU 

Definition at line 38 of file SparseLU_Memory.h.

◆ anonymous enum

anonymous enum
Enumerator
PreconditionIfMoreColsThanRows 
PreconditionIfMoreRowsThanCols 

Definition at line 30 of file JacobiSVD.h.

◆ anonymous enum

anonymous enum
Enumerator
ShardByRow 
ShardByCol 

Definition at line 17 of file TensorContractionBlocking.h.

◆ anonymous enum

anonymous enum
Enumerator
Rhs 
Lhs 

Definition at line 17 of file TensorContractionMapper.h.

◆ ComparisonName

Enumerator
cmp_EQ 
cmp_LT 
cmp_LE 
cmp_UNORD 
cmp_NEQ 
cmp_GT 
cmp_GE 

Definition at line 550 of file Constants.h.

◆ GEBPPacketSizeType

Enumerator
GEBPPacketFull 
GEBPPacketHalf 
GEBPPacketQuarter 

Definition at line 18 of file products/GeneralBlockPanelKernel.h.

◆ GEMVPacketSizeType

Enumerator
GEMVPacketFull 
GEMVPacketHalf 
GEMVPacketQuarter 

Definition at line 17 of file GeneralMatrixVector.h.

◆ IgammaComputationMode

Enumerator
VALUE 
DERIVATIVE 
SAMPLE_DERIVATIVE 

Definition at line 729 of file SpecialFunctionsImpl.h.

◆ MemType

Enumerator
LUSUP 
UCOL 
LSUB 
USUB 
LLVL 
ULVL 

Definition at line 74 of file SparseLU_Structs.h.

◆ PermPermProduct_t

Enumerator
PermPermProduct 

Definition at line 18 of file PermutationMatrix.h.

◆ SignMatrix

Enumerator
PositiveSemiDef 
NegativeSemiDef 
ZeroSign 
Indefinite 

Definition at line 31 of file LDLT.h.

◆ TensorBlockKind

Enumerator
kExpr 
kView 
kMaterializedInScratch 
kMaterializedInOutput 

Definition at line 589 of file TensorBlock.h.

◆ TensorBlockShapeType

Enumerator
kUniformAllDims 
kSkewedInnerDims 

Definition at line 73 of file TensorBlock.h.

◆ TiledEvaluation

Enumerator
Off 
On 

Definition at line 158 of file TensorForwardDeclarations.h.

Function Documentation

◆ __UNPACK_TYPE__()

template<typename Packet >
EIGEN_STRONG_INLINE Eigen::internal::__UNPACK_TYPE__ ( Packet  ) const &

Definition at line 1123 of file AltiVec/PacketMath.h.

◆ _EIGEN_DECLARE_CONST_FAST_Packet16uc()

static Eigen::internal::_EIGEN_DECLARE_CONST_FAST_Packet16uc ( ONE  ,
 
)
static

◆ _EIGEN_DECLARE_CONST_FAST_Packet2d()

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

◆ _EIGEN_DECLARE_CONST_FAST_Packet2l() [1/2]

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

◆ _EIGEN_DECLARE_CONST_FAST_Packet2l() [2/2]

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

◆ _EIGEN_DECLARE_CONST_FAST_Packet4f() [1/2]

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

◆ _EIGEN_DECLARE_CONST_FAST_Packet4f() [2/2]

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

◆ _EIGEN_DECLARE_CONST_FAST_Packet4i() [1/7]

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

◆ _EIGEN_DECLARE_CONST_FAST_Packet4i() [2/7]

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

◆ _EIGEN_DECLARE_CONST_FAST_Packet4i() [3/7]

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

◆ _EIGEN_DECLARE_CONST_FAST_Packet4i() [4/7]

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

◆ _EIGEN_DECLARE_CONST_FAST_Packet4i() [5/7]

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

◆ _EIGEN_DECLARE_CONST_FAST_Packet4i() [6/7]

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

◆ _EIGEN_DECLARE_CONST_FAST_Packet4i() [7/7]

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

◆ _EIGEN_DECLARE_CONST_FAST_Packet4ui() [1/2]

static Eigen::internal::_EIGEN_DECLARE_CONST_FAST_Packet4ui ( SIGN  ,
0x80000000u   
)
static

◆ _EIGEN_DECLARE_CONST_FAST_Packet4ui() [2/2]

static Eigen::internal::_EIGEN_DECLARE_CONST_FAST_Packet4ui ( PREV0DOT5  ,
0x3EFFFFFFu   
)
static

◆ _EIGEN_DECLARE_CONST_FAST_Packet8us()

static Eigen::internal::_EIGEN_DECLARE_CONST_FAST_Packet8us ( ONE  ,
 
)
static

◆ _EIGEN_DECLARE_CONST_Packet2d() [1/15]

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

◆ _EIGEN_DECLARE_CONST_Packet2d() [2/15]

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

◆ _EIGEN_DECLARE_CONST_Packet2d() [3/15]

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

◆ _EIGEN_DECLARE_CONST_Packet2d() [4/15]

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

◆ _EIGEN_DECLARE_CONST_Packet2d() [5/15]

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

◆ _EIGEN_DECLARE_CONST_Packet2d() [6/15]

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

◆ _EIGEN_DECLARE_CONST_Packet2d() [7/15]

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

◆ _EIGEN_DECLARE_CONST_Packet2d() [8/15]

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

◆ _EIGEN_DECLARE_CONST_Packet2d() [9/15]

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

◆ _EIGEN_DECLARE_CONST_Packet2d() [10/15]

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

◆ _EIGEN_DECLARE_CONST_Packet2d() [11/15]

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

◆ _EIGEN_DECLARE_CONST_Packet2d() [12/15]

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

◆ _EIGEN_DECLARE_CONST_Packet2d() [13/15]

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

◆ _EIGEN_DECLARE_CONST_Packet2d() [14/15]

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

◆ _EIGEN_DECLARE_CONST_Packet2d() [15/15]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [1/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [2/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [3/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [4/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [5/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [6/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [7/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [8/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [9/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [10/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [11/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [12/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [13/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [14/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [15/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [16/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [17/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [18/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [19/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [20/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [21/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [22/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [23/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [24/25]

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

◆ _EIGEN_DECLARE_CONST_Packet4f() [25/25]

static Eigen::internal::_EIGEN_DECLARE_CONST_Packet4f ( cephes_exp_p5  ,
5.0000001201E-  1f 
)
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

◆ absolute_split()

template<typename Packet >
EIGEN_STRONG_INLINE void Eigen::internal::absolute_split ( const Packet x,
Packet n,
Packet r 
)

Definition at line 883 of file GenericPacketMathFunctions.h.

◆ aligned_delete()

template<typename T >
EIGEN_DEVICE_FUNC void Eigen::internal::aligned_delete ( T ptr,
std::size_t  size 
)
inline

Definition at line 361 of file Memory.h.

◆ aligned_free()

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

Definition at line 198 of file Memory.h.

◆ aligned_malloc()

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

Definition at line 174 of file Memory.h.

◆ aligned_new()

template<typename T >
EIGEN_DEVICE_FUNC T* Eigen::internal::aligned_new ( std::size_t  size)
inline

Definition at line 326 of file Memory.h.

◆ aligned_realloc()

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

Definition at line 215 of file Memory.h.

◆ all_indices_known_statically()

template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool Eigen::internal::all_indices_known_statically ( )
static

Definition at line 695 of file TensorIndexList.h.

◆ amd_flip()

template<typename T >
T Eigen::internal::amd_flip ( const T i)
inline

Definition at line 28 of file Amd.h.

◆ amd_mark()

template<typename T0 , typename T1 >
void Eigen::internal::amd_mark ( const T0 *  w,
const T1 j 
)
inline

Definition at line 31 of file Amd.h.

◆ amd_marked()

template<typename T0 , typename T1 >
bool Eigen::internal::amd_marked ( const T0 *  w,
const T1 j 
)
inline

Definition at line 30 of file Amd.h.

◆ amd_unflip()

template<typename T >
T Eigen::internal::amd_unflip ( const T i)
inline

Definition at line 29 of file Amd.h.

◆ apply_bit_op()

template<typename T , typename Bits , typename Func >
T Eigen::internal::apply_bit_op ( Bits  a,
Bits  b,
Func  f 
)

Definition at line 34 of file packetmath_test_shared.h.

◆ 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 
)

Definition at line 86 of file BlockHouseholder.h.

◆ apply_rotation_in_the_plane()

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

Applies the clock wise 2D rotation j to the set of 2D vectors of coordinates x and y: $ \left ( \begin{array}{cc} x \\ y \end{array} \right ) = J \left ( \begin{array}{cc} x \\ y \end{array} \right ) $

See also
MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()

Definition at line 453 of file Jacobi.h.

◆ array_apply()

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

Definition at line 448 of file CXX11Meta.h.

◆ array_apply_and_reduce()

template<typename Reducer , typename Op , typename A , std::size_t N>
constexpr EIGEN_STRONG_INLINE auto Eigen::internal::array_apply_and_reduce ( array< A, N a) -> decltype(h_array_apply_and_reduce<Reducer, Op, A, N>(a, typename gen_numeric_list<int, N>::type()))

Definition at line 462 of file CXX11Meta.h.

◆ array_get() [1/10]

template<DenseIndex n, typename Index , std::size_t Rank>
const Index Eigen::internal::array_get ( DimensionList< Index, Rank > &  )

Definition at line 39 of file TensorDimensionList.h.

◆ array_get() [2/10]

template<DenseIndex n, typename Index , std::size_t Rank>
const Index Eigen::internal::array_get ( const DimensionList< Index, Rank > &  )

Definition at line 42 of file TensorDimensionList.h.

◆ array_get() [3/10]

template<std::size_t I_, class T >
constexpr T& Eigen::internal::array_get ( std::vector< T > &  a)
inline

Definition at line 50 of file CXX11Workarounds.h.

◆ array_get() [4/10]

template<std::size_t I_, class T >
constexpr T&& Eigen::internal::array_get ( std::vector< T > &&  a)
inline

Definition at line 51 of file CXX11Workarounds.h.

◆ array_get() [5/10]

template<std::size_t I_, class T >
constexpr T const& Eigen::internal::array_get ( std::vector< T > const &  a)
inline

Definition at line 52 of file CXX11Workarounds.h.

◆ array_get() [6/10]

template<std::size_t n, typename T , T a, T... as>
constexpr T Eigen::internal::array_get ( const numeric_list< T, a, as... > &  )

Definition at line 123 of file CXX11Meta.h.

◆ array_get() [7/10]

template<std::size_t I_, class T , std::size_t N>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T& Eigen::internal::array_get ( array< T, N > &  a)

Definition at line 201 of file EmulateArray.h.

◆ array_get() [8/10]

template<std::size_t I_, class T , std::size_t N>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T& Eigen::internal::array_get ( const array< T, N > &  a)

Definition at line 205 of file EmulateArray.h.

◆ array_get() [9/10]

template<std::ptrdiff_t n, typename std::ptrdiff_t... Indices>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t Eigen::internal::array_get ( const Sizes< Indices... > &  )

Definition at line 439 of file TensorDimensions.h.

◆ array_get() [10/10]

template<std::ptrdiff_t n>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t Eigen::internal::array_get ( const Sizes<> &  )

Definition at line 442 of file TensorDimensions.h.

◆ array_prod() [1/3]

template<typename std::ptrdiff_t... Indices>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t Eigen::internal::array_prod ( const Sizes< Indices... > &  )

Definition at line 140 of file TensorDimensions.h.

◆ array_prod() [2/3]

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

Definition at line 398 of file CXX11Meta.h.

◆ array_prod() [3/3]

template<typename t >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE t Eigen::internal::array_prod ( const std::vector< t > &  a)

Definition at line 404 of file CXX11Meta.h.

◆ array_reduce()

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

Definition at line 384 of file CXX11Meta.h.

◆ array_reverse()

template<typename T , std::size_t N>
constexpr EIGEN_STRONG_INLINE array<T, N> Eigen::internal::array_reverse ( array< T, N arr)

Definition at line 344 of file CXX11Meta.h.

◆ array_sum()

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

Definition at line 392 of file CXX11Meta.h.

◆ array_zip()

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

Definition at line 420 of file CXX11Meta.h.

◆ array_zip_and_reduce()

template<typename Reducer , typename Op , typename A , typename B , std::size_t N>
constexpr EIGEN_STRONG_INLINE auto Eigen::internal::array_zip_and_reduce ( array< A, N a,
array< B, N b 
) -> decltype(h_array_zip_and_reduce<Reducer, Op, A, B, N>(a, b, typename gen_numeric_list<int, N>::type()))

Definition at line 434 of file CXX11Meta.h.

◆ assign_sparse_to_sparse()

template<typename DstXprType , typename SrcXprType >
void Eigen::internal::assign_sparse_to_sparse ( DstXprType &  dst,
const SrcXprType &  src 
)

Definition at line 71 of file SparseAssign.h.

◆ asSluMatrix()

template<typename MatrixType >
SluMatrix Eigen::internal::asSluMatrix ( MatrixType mat)

Definition at line 291 of file SuperLUSupport.h.

◆ band()

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

Definition at line 1180 of file MatrixProduct.h.

◆ bcouple() [1/2]

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

Definition at line 158 of file MatrixProductCommon.h.

◆ bcouple() [2/2]

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

Definition at line 182 of file MatrixProductCommon.h.

◆ bcouple_common() [1/2]

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

Definition at line 144 of file MatrixProductCommon.h.

◆ bcouple_common() [2/2]

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

Definition at line 174 of file MatrixProductCommon.h.

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

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

Definition at line 192 of file MatrixProductCommon.h.

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

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

Definition at line 206 of file MatrixProductCommon.h.

◆ Bf16ToF32() [1/3]

EIGEN_STRONG_INLINE Packet8f Eigen::internal::Bf16ToF32 ( const Packet8bf a)

Definition at line 1260 of file AVX/PacketMath.h.

◆ Bf16ToF32() [2/3]

EIGEN_STRONG_INLINE Packet16f Eigen::internal::Bf16ToF32 ( const Packet16bf a)

Definition at line 1940 of file AVX512/PacketMath.h.

◆ Bf16ToF32() [3/3]

EIGEN_STRONG_INLINE Packet4f Eigen::internal::Bf16ToF32 ( const Packet4bf p)

Definition at line 3414 of file NEON/PacketMath.h.

◆ Bf16ToF32Even()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::Bf16ToF32Even ( const Packet8bf bf)

Definition at line 1230 of file AltiVec/PacketMath.h.

◆ Bf16ToF32Odd()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::Bf16ToF32Odd ( const Packet8bf bf)

Definition at line 1234 of file AltiVec/PacketMath.h.

◆ 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 
)

Definition at line 29 of file BiCGSTAB.h.

◆ biteq()

template<typename T >
bool Eigen::internal::biteq ( T  a,
T  b 
)

Definition at line 66 of file packetmath_test_shared.h.

◆ bits()

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

Definition at line 28 of file packetmath_test_shared.h.

◆ bload() [1/3]

template<typename DataMapper , typename Packet , typename Index , const Index accCols, int N, int StorageOrder>
EIGEN_ALWAYS_INLINE void Eigen::internal::bload ( PacketBlock< Packet, 4 > &  acc,
const DataMapper &  res,
Index  row,
Index  col 
)

Definition at line 1199 of file MatrixProduct.h.

◆ bload() [2/3]

template<typename DataMapper , typename Packet , typename Index , const Index accCols, int N, int StorageOrder>
EIGEN_ALWAYS_INLINE void Eigen::internal::bload ( PacketBlock< Packet, 8 > &  acc,
const DataMapper &  res,
Index  row,
Index  col 
)

Definition at line 1216 of file MatrixProduct.h.

◆ bload() [3/3]

template<typename DataMapper , typename Packet , typename Index , const Index accCols, int N, int StorageOrder>
EIGEN_ALWAYS_INLINE void Eigen::internal::bload ( PacketBlock< Packet, 2 > &  acc,
const DataMapper &  res,
Index  row,
Index  col 
)

Definition at line 1240 of file MatrixProduct.h.

◆ BlockedInPlaceTranspose()

template<typename MatrixType , Index Alignment>
void Eigen::internal::BlockedInPlaceTranspose ( MatrixType m)

Definition at line 264 of file Transpose.h.

◆ blueNorm_impl()

template<typename Derived >
NumTraits<typename traits<Derived>::Scalar>::Real Eigen::internal::blueNorm_impl ( const EigenBase< Derived > &  _vec)
inline

Definition at line 120 of file StableNorm.h.

◆ bmask()

template<typename Packet >
EIGEN_ALWAYS_INLINE Packet Eigen::internal::bmask ( const int  remaining_rows)

Definition at line 1253 of file MatrixProduct.h.

◆ bmask< Packet2d >()

template<>
EIGEN_ALWAYS_INLINE Packet2d Eigen::internal::bmask< Packet2d > ( const int  remaining_rows)

Definition at line 1267 of file MatrixProduct.h.

◆ bruteforce_det3_helper()

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

Definition at line 20 of file Determinant.h.

◆ bscale() [1/3]

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

Definition at line 1137 of file MatrixProduct.h.

◆ bscale() [2/3]

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

Definition at line 1146 of file MatrixProduct.h.

◆ bscale() [3/3]

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

Definition at line 1277 of file MatrixProduct.h.

◆ bscalec() [1/2]

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

Definition at line 1168 of file MatrixProduct.h.

◆ bscalec() [2/2]

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

Definition at line 1189 of file MatrixProduct.h.

◆ bscalec_common() [1/2]

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

Definition at line 1152 of file MatrixProduct.h.

◆ bscalec_common() [2/2]

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

Definition at line 1161 of file MatrixProduct.h.

◆ bsetzero() [1/2]

template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE void Eigen::internal::bsetzero ( PacketBlock< Packet, 4 > &  acc)

Definition at line 1121 of file MatrixProduct.h.

◆ bsetzero() [2/2]

template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE void Eigen::internal::bsetzero ( PacketBlock< Packet, 1 > &  acc)

Definition at line 1130 of file MatrixProduct.h.

◆ bsetzeroMMA()

template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE void Eigen::internal::bsetzeroMMA ( __vector_quad *  acc)

Definition at line 27 of file MatrixProductMMA.h.

◆ c_to_fortran_numbering()

template<typename MatrixType >
void Eigen::internal::c_to_fortran_numbering ( MatrixType mat)

Definition at line 97 of file PaStiXSupport.h.

◆ call_assignment() [1/6]

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

Definition at line 89 of file evaluators.cpp.

◆ call_assignment() [2/6]

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

Definition at line 834 of file AssignEvaluator.h.

◆ call_assignment() [3/6]

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

Definition at line 840 of file AssignEvaluator.h.

◆ call_assignment() [4/6]

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

Definition at line 848 of file AssignEvaluator.h.

◆ call_assignment() [5/6]

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

Definition at line 856 of file AssignEvaluator.h.

◆ call_assignment() [6/6]

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

Definition at line 865 of file AssignEvaluator.h.

◆ call_assignment_no_alias() [1/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 
)

Definition at line 873 of file AssignEvaluator.h.

◆ call_assignment_no_alias() [2/2]

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

Definition at line 915 of file AssignEvaluator.h.

◆ call_assignment_no_alias_no_transpose() [1/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 
)

Definition at line 922 of file AssignEvaluator.h.

◆ call_assignment_no_alias_no_transpose() [2/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 
)

Definition at line 933 of file AssignEvaluator.h.

◆ call_dense_assignment_loop() [1/3]

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

Definition at line 769 of file AssignEvaluator.h.

◆ call_dense_assignment_loop() [2/3]

template<typename DstXprType >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::call_dense_assignment_loop ( DstXprType &  dst,
const Eigen::CwiseNullaryOp< Eigen::internal::scalar_constant_op< typename DstXprType::Scalar >, DstXprType > &  src,
const internal::assign_op< typename DstXprType::Scalar, typename DstXprType::Scalar > &  func 
)

Definition at line 791 of file AssignEvaluator.h.

◆ call_dense_assignment_loop() [3/3]

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

Definition at line 799 of file AssignEvaluator.h.

◆ call_restricted_packet_assignment()

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

Definition at line 95 of file evaluators.cpp.

◆ call_restricted_packet_assignment_no_alias()

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

Definition at line 895 of file AssignEvaluator.h.

◆ call_triangular_assignment_loop() [1/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 
)

Definition at line 802 of file TriangularMatrix.h.

◆ call_triangular_assignment_loop() [2/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 
)

Definition at line 830 of file TriangularMatrix.h.

◆ cast() [1/3]

template<>
EIGEN_STRONG_INLINE double Eigen::internal::cast ( const AnnoyingScalar x)

Definition at line 148 of file AnnoyingScalar.h.

◆ cast() [2/3]

template<>
EIGEN_STRONG_INLINE float Eigen::internal::cast ( const AnnoyingScalar x)

Definition at line 149 of file AnnoyingScalar.h.

◆ cast() [3/3]

template<typename OldType , typename NewType >
EIGEN_DEVICE_FUNC NewType Eigen::internal::cast ( const OldType &  x)
inline

Definition at line 460 of file Eigen/src/Core/MathFunctions.h.

◆ cat256()

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

Definition at line 446 of file AVX512/PacketMath.h.

◆ check_DenseIndex_is_signed()

static void Eigen::internal::check_DenseIndex_is_signed ( )
inlinestatic

Definition at line 20 of file DenseBase.h.

◆ check_for_aliasing()

template<typename Dst , typename Src >
void Eigen::internal::check_for_aliasing ( const Dst &  dst,
const Src &  src 
)

Definition at line 452 of file Transpose.h.

◆ check_size_for_overflow()

template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void Eigen::internal::check_size_for_overflow ( std::size_t  size)

Definition at line 316 of file Memory.h.

◆ check_static_allocation_size()

template<typename T , int Size>
EIGEN_DEVICE_FUNC void Eigen::internal::check_static_allocation_size ( )

Definition at line 29 of file DenseStorage.h.

◆ check_that_malloc_is_allowed()

EIGEN_DEVICE_FUNC void Eigen::internal::check_that_malloc_is_allowed ( )
inline

Definition at line 167 of file Memory.h.

◆ chkder()

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

Definition at line 9 of file chkder.h.

◆ cm_factorize_p()

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

Definition at line 193 of file CholmodSupport.h.

◆ cm_factorize_p< SuiteSparse_long >()

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

Definition at line 195 of file CholmodSupport.h.

◆ cm_solve()

template<typename _StorageIndex >
cholmod_dense* Eigen::internal::cm_solve ( int  sys,
cholmod_factor &  L,
cholmod_dense &  B,
cholmod_common &  Common 
)
inline

Definition at line 186 of file CholmodSupport.h.

◆ cm_solve< SuiteSparse_long >()

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

Definition at line 187 of file CholmodSupport.h.

◆ cm_spsolve()

template<typename _StorageIndex >
cholmod_sparse* Eigen::internal::cm_spsolve ( int  sys,
cholmod_factor &  L,
cholmod_sparse &  B,
cholmod_common &  Common 
)
inline

Definition at line 189 of file CholmodSupport.h.

◆ cm_spsolve< SuiteSparse_long >()

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

Definition at line 190 of file CholmodSupport.h.

◆ cofactor_3x3()

template<typename MatrixType , int i, int j>
EIGEN_DEVICE_FUNC MatrixType::Scalar Eigen::internal::cofactor_3x3 ( const MatrixType m)
inline

Definition at line 127 of file InverseImpl.h.

◆ cofactor_4x4()

template<typename MatrixType , int i, int j>
EIGEN_DEVICE_FUNC MatrixType::Scalar Eigen::internal::cofactor_4x4 ( const MatrixType matrix)
inline

Definition at line 218 of file InverseImpl.h.

◆ 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
matThe matrix in column-major format.
parentThe elimination tree
firstRowEltThe column index of the first element in each row
permThe permutation to apply to the column of mat

Definition at line 61 of file SparseColEtree.h.

◆ combine_scalar_factors() [1/2]

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

Definition at line 568 of file BlasUtil.h.

◆ combine_scalar_factors() [2/2]

template<typename ResScalar , typename Lhs , typename Rhs >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE ResScalar Eigen::internal::combine_scalar_factors ( const Lhs lhs,
const Rhs rhs 
)

Definition at line 573 of file BlasUtil.h.

◆ complex_log()

template<typename T >
EIGEN_DEVICE_FUNC std::complex< T > Eigen::internal::complex_log ( const std::complex< T > &  z)

Definition at line 188 of file MathFunctionsImpl.h.

◆ complex_rsqrt()

template<typename T >
EIGEN_DEVICE_FUNC std::complex< T > Eigen::internal::complex_rsqrt ( const std::complex< T > &  a_x)

Definition at line 148 of file MathFunctionsImpl.h.

◆ complex_sqrt()

template<typename T >
EIGEN_DEVICE_FUNC std::complex< T > Eigen::internal::complex_sqrt ( const std::complex< T > &  a_x)

Definition at line 111 of file MathFunctionsImpl.h.

◆ 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

Definition at line 76 of file InverseImpl.h.

◆ 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

Definition at line 141 of file InverseImpl.h.

◆ computeFromTridiagonal_impl()

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

Definition at line 504 of file SelfAdjointEigenSolver.h.

◆ 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]kInput: the third dimension of the product. Output: the blocking size along the same dimension.
[in,out]mInput: the number of rows of the left hand side. Output: the blocking size along the same dimension.
[in,out]nInput: 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

Definition at line 339 of file products/GeneralBlockPanelKernel.h.

◆ 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

Definition at line 347 of file products/GeneralBlockPanelKernel.h.

◆ conditional_aligned_delete()

template<typename T , bool Align>
EIGEN_DEVICE_FUNC void Eigen::internal::conditional_aligned_delete ( T ptr,
std::size_t  size 
)
inline

Definition at line 370 of file Memory.h.

◆ 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

Definition at line 442 of file Memory.h.

◆ conditional_aligned_free()

template<bool Align>
EIGEN_DEVICE_FUNC void Eigen::internal::conditional_aligned_free ( void *  ptr)
inline

Definition at line 257 of file Memory.h.

◆ conditional_aligned_free< false >()

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

Definition at line 262 of file Memory.h.

◆ conditional_aligned_malloc()

template<bool Align>
EIGEN_DEVICE_FUNC void* Eigen::internal::conditional_aligned_malloc ( std::size_t  size)
inline

Definition at line 239 of file Memory.h.

◆ conditional_aligned_malloc< false >()

Definition at line 244 of file Memory.h.

◆ conditional_aligned_new()

template<typename T , bool Align>
EIGEN_DEVICE_FUNC T* Eigen::internal::conditional_aligned_new ( std::size_t  size)
inline

Definition at line 342 of file Memory.h.

◆ conditional_aligned_new_auto()

template<typename T , bool Align>
EIGEN_DEVICE_FUNC T* Eigen::internal::conditional_aligned_new_auto ( std::size_t  size)
inline

Definition at line 399 of file Memory.h.

◆ 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

Definition at line 268 of file Memory.h.

◆ conditional_aligned_realloc< false >()

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

Definition at line 273 of file Memory.h.

◆ 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

Definition at line 376 of file Memory.h.

◆ 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

Definition at line 420 of file Memory.h.

◆ 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 
)

Definition at line 28 of file ConjugateGradient.h.

◆ 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

Definition at line 18 of file ConservativeSparseSparseProduct.h.

◆ const_cast_ptr()

template<typename T >
EIGEN_DEVICE_FUNC T* Eigen::internal::const_cast_ptr ( const T ptr)
inline

Definition at line 477 of file XprHelper.h.

◆ construct_elements_of_array()

template<typename T >
EIGEN_DEVICE_FUNC T* Eigen::internal::construct_elements_of_array ( T ptr,
std::size_t  size 
)
inline

Definition at line 295 of file Memory.h.

◆ convert_index()

template<typename IndexDest , typename IndexSrc >
EIGEN_DEVICE_FUNC IndexDest Eigen::internal::convert_index ( const IndexSrc &  idx)
inline

Definition at line 31 of file XprHelper.h.

◆ copy_bool()

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

Definition at line 1004 of file Macros.h.

◆ covar()

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

Definition at line 20 of file LMcovar.h.

◆ cs_tdfs()

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

Definition at line 50 of file Amd.h.

◆ cs_wclear()

template<typename StorageIndex >
static StorageIndex Eigen::internal::cs_wclear ( StorageIndex  mark,
StorageIndex  lemax,
StorageIndex *  w,
StorageIndex  n 
)
static

Definition at line 35 of file Amd.h.

◆ destruct_elements_of_array()

template<typename T >
EIGEN_DEVICE_FUNC void Eigen::internal::destruct_elements_of_array ( T ptr,
std::size_t  size 
)
inline

Definition at line 285 of file Memory.h.

◆ dogleg()

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

Definition at line 6 of file dogleg.h.

◆ doubleword_reciprocal()

template<typename Packet >
void Eigen::internal::doubleword_reciprocal ( const Packet x,
Packet recip_hi,
Packet recip_lo 
)

Definition at line 1046 of file GenericPacketMathFunctions.h.

◆ EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE() [1/6]

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

◆ EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE() [2/6]

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

◆ EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE() [3/6]

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

◆ EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE() [4/6]

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

◆ EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE() [5/6]

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

◆ EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE() [6/6]

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

◆ EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT() [1/6]

Eigen::internal::EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT ( assign_op  ,
scalar_sum_op  ,
add_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 ( sub_assign_op  ,
scalar_sum_op  ,
sub_assign_op   
)

◆ EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT() [4/6]

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

◆ EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT() [5/6]

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

◆ EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT() [6/6]

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

◆ EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR() [1/4]

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

◆ EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR() [2/4]

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

◆ EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR() [3/4]

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

◆ EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR() [4/4]

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

◆ EIGEN_MATHFUNC_RETVAL() [1/2]

template<typename Scalar >
Eigen::internal::EIGEN_MATHFUNC_RETVAL ( random  ,
Scalar   
) const &
inline

◆ EIGEN_MATHFUNC_RETVAL() [2/2]

template<typename Scalar >
Eigen::internal::EIGEN_MATHFUNC_RETVAL ( random  ,
Scalar   
)
inline

Definition at line 951 of file Eigen/src/Core/MathFunctions.h.

◆ EIGEN_MEMBER_FUNCTOR() [1/7]

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

◆ EIGEN_MEMBER_FUNCTOR() [2/7]

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

◆ EIGEN_MEMBER_FUNCTOR() [3/7]

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

◆ EIGEN_MEMBER_FUNCTOR() [4/7]

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

◆ EIGEN_MEMBER_FUNCTOR() [5/7]

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

◆ EIGEN_MEMBER_FUNCTOR() [6/7]

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

◆ EIGEN_MEMBER_FUNCTOR() [7/7]

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

◆ eigen_neon_shuffle_mask()

static EIGEN_STRONG_INLINE int Eigen::internal::eigen_neon_shuffle_mask ( int  p,
int  q,
int  r,
int  s 
)
static

Definition at line 111 of file NEON/PacketMath.h.

◆ eigen_pastix() [1/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

Definition at line 67 of file PaStiXSupport.h.

◆ eigen_pastix() [2/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

Definition at line 74 of file PaStiXSupport.h.

◆ 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< float > *  vals,
int perm,
int invp,
std::complex< float > *  x,
int  nbrhs,
int iparm,
double *  dparm 
)
inline

Definition at line 81 of file PaStiXSupport.h.

◆ 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< double > *  vals,
int perm,
int invp,
std::complex< double > *  x,
int  nbrhs,
int iparm,
double *  dparm 
)
inline

Definition at line 88 of file PaStiXSupport.h.

◆ 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

Definition at line 40 of file SparseColEtree.h.

◆ eval_expr_given_size() [1/3]

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

Definition at line 63 of file IndexedViewHelper.h.

◆ eval_expr_given_size() [2/3]

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

Definition at line 66 of file IndexedViewHelper.h.

◆ eval_expr_given_size() [3/3]

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

Definition at line 69 of file IndexedViewHelper.h.

◆ evaluateProductBlockingSizesHeuristic()

template<typename LhsScalar , typename RhsScalar , int KcFactor, typename Index >
void Eigen::internal::evaluateProductBlockingSizesHeuristic ( Index k,
Index m,
Index n,
Index  num_threads = 1 
)

Definition at line 124 of file products/GeneralBlockPanelKernel.h.

◆ extract128()

template<int I_>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::extract128 ( Packet8d  x)

Definition at line 442 of file AVX512/PacketMath.h.

◆ extract256()

template<int I_>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::extract256 ( Packet16f  x)

Definition at line 437 of file AVX512/PacketMath.h.

◆ extract_data()

template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T::Scalar* Eigen::internal::extract_data ( const T m)

Definition at line 533 of file BlasUtil.h.

◆ F32MaskToBf16Mask()

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::F32MaskToBf16Mask ( const Packet4f p)

Definition at line 3419 of file NEON/PacketMath.h.

◆ F32ToBf16() [1/5]

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::F32ToBf16 ( Packet4f  p4f)

Definition at line 1252 of file AltiVec/PacketMath.h.

◆ F32ToBf16() [2/5]

EIGEN_STRONG_INLINE Packet8bf Eigen::internal::F32ToBf16 ( const Packet8f a)

Definition at line 1274 of file AVX/PacketMath.h.

◆ F32ToBf16() [3/5]

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

Definition at line 1292 of file AltiVec/PacketMath.h.

◆ F32ToBf16() [4/5]

EIGEN_STRONG_INLINE Packet16bf Eigen::internal::F32ToBf16 ( const Packet16f a)

Definition at line 1945 of file AVX512/PacketMath.h.

◆ F32ToBf16() [5/5]

EIGEN_STRONG_INLINE Packet4bf Eigen::internal::F32ToBf16 ( const Packet4f p)

Definition at line 3387 of file NEON/PacketMath.h.

◆ F32ToBf16Bool()

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

Definition at line 1244 of file AltiVec/PacketMath.h.

◆ fast_twosum() [1/3]

template<typename Packet >
EIGEN_STRONG_INLINE void Eigen::internal::fast_twosum ( const Packet x,
const Packet y,
Packet s_hi,
Packet s_lo 
)

Definition at line 892 of file GenericPacketMathFunctions.h.

◆ fast_twosum() [2/3]

template<typename Packet >
EIGEN_STRONG_INLINE void Eigen::internal::fast_twosum ( const Packet x_hi,
const Packet x_lo,
const Packet y_hi,
const Packet y_lo,
Packet s_hi,
Packet s_lo 
)

Definition at line 981 of file GenericPacketMathFunctions.h.

◆ fast_twosum() [3/3]

template<typename Packet >
EIGEN_STRONG_INLINE void Eigen::internal::fast_twosum ( const Packet x,
const Packet y_hi,
const Packet y_lo,
Packet s_hi,
Packet s_lo 
)

Definition at line 995 of file GenericPacketMathFunctions.h.

◆ fdjac1()

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

Definition at line 6 of file fdjac1.h.

◆ fftw_cast() [1/4]

template<typename T >
T* Eigen::internal::fftw_cast ( const T p)
inline

Definition at line 24 of file ei_fftw_impl.h.

◆ fftw_cast() [2/4]

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

Definition at line 30 of file ei_fftw_impl.h.

◆ fftw_cast() [3/4]

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

Definition at line 36 of file ei_fftw_impl.h.

◆ fftw_cast() [4/4]

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

Definition at line 42 of file ei_fftw_impl.h.

◆ first()

template<typename T >
EIGEN_CONSTEXPR Index Eigen::internal::first ( const T x)

Definition at line 81 of file IndexedViewHelper.h.

◆ first_aligned() [1/2]

template<int Alignment, typename Scalar , typename Index >
EIGEN_DEVICE_FUNC Index Eigen::internal::first_aligned ( const Scalar array,
Index  size 
)
inline

Definition at line 469 of file Memory.h.

◆ first_aligned() [2/2]

template<int Alignment, typename Derived >
static Index Eigen::internal::first_aligned ( const DenseBase< Derived > &  m)
inlinestatic

Definition at line 643 of file DenseCoeffsBase.h.

◆ first_default_aligned() [1/2]

template<typename Scalar , typename Index >
EIGEN_DEVICE_FUNC Index Eigen::internal::first_default_aligned ( const Scalar array,
Index  size 
)
inline

Definition at line 497 of file Memory.h.

◆ first_default_aligned() [2/2]

template<typename Derived >
static Index Eigen::internal::first_default_aligned ( const DenseBase< Derived > &  m)
inlinestatic

Definition at line 650 of file DenseCoeffsBase.h.

◆ first_multiple()

template<typename Index >
Index Eigen::internal::first_multiple ( Index  size,
Index  base 
)
inline

Definition at line 506 of file Memory.h.

◆ flipsign()

template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T Eigen::internal::flipsign ( const T should_flipsign,
const T x 
)

Definition at line 491 of file SpecialFunctionsImpl.h.

◆ flipsign< double >()

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

Definition at line 500 of file SpecialFunctionsImpl.h.

◆ flipsign< float >()

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

Definition at line 506 of file SpecialFunctionsImpl.h.

◆ float2half() [1/2]

EIGEN_STRONG_INLINE Packet8h Eigen::internal::float2half ( const Packet8f a)

Definition at line 1007 of file AVX/PacketMath.h.

◆ float2half() [2/2]

EIGEN_STRONG_INLINE Packet16h Eigen::internal::float2half ( const Packet16f a)

Definition at line 1456 of file AVX512/PacketMath.h.

◆ fortran_to_c_numbering()

template<typename MatrixType >
void Eigen::internal::fortran_to_c_numbering ( MatrixType mat)

Definition at line 111 of file PaStiXSupport.h.

◆ gemm()

template<typename Scalar , typename Index , typename Packet , typename RhsPacket , typename DataMapper , const Index accRows, const Index accCols>
EIGEN_STRONG_INLINE void Eigen::internal::gemm ( const DataMapper &  res,
const Scalar blockA,
const Scalar blockB,
Index  rows,
Index  depth,
Index  cols,
Scalar  alpha,
Index  strideA,
Index  strideB,
Index  offsetA,
Index  offsetB 
)

Definition at line 1697 of file MatrixProduct.h.

◆ gemm_complex()

template<typename LhsScalar , typename RhsScalar , typename Scalarc , typename Scalar , typename Index , typename Packet , typename Packetc , typename RhsPacket , typename DataMapper , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE void Eigen::internal::gemm_complex ( const DataMapper &  res,
const LhsScalar *  blockAc,
const RhsScalar *  blockBc,
Index  rows,
Index  depth,
Index  cols,
Scalarc  alpha,
Index  strideA,
Index  strideB,
Index  offsetA,
Index  offsetB 
)

Definition at line 2317 of file MatrixProduct.h.

◆ gemm_complex_extra_col()

template<typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE void Eigen::internal::gemm_complex_extra_col ( const DataMapper &  res,
const Scalar lhs_base,
const Scalar rhs_base,
Index  depth,
Index  strideA,
Index  offsetA,
Index  strideB,
Index  row,
Index  col,
Index  remaining_rows,
Index  remaining_cols,
const Packet pAlphaReal,
const Packet pAlphaImag 
)

Definition at line 1814 of file MatrixProduct.h.

◆ gemm_complex_extra_row()

template<typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE void Eigen::internal::gemm_complex_extra_row ( const DataMapper &  res,
const Scalar lhs_base,
const Scalar rhs_base,
Index  depth,
Index  strideA,
Index  offsetA,
Index  strideB,
Index  row,
Index  col,
Index  rows,
Index  cols,
Index  remaining_rows,
const Packet pAlphaReal,
const Packet pAlphaImag,
const Packet pMask 
)

Definition at line 1912 of file MatrixProduct.h.

◆ gemm_complex_unrolled_col()

template<typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE void Eigen::internal::gemm_complex_unrolled_col ( const DataMapper &  res,
const Scalar lhs_base,
const Scalar rhs_base,
Index  depth,
Index  strideA,
Index  offsetA,
Index  strideB,
Index row,
Index  rows,
Index  col,
Index  remaining_cols,
const Packet pAlphaReal,
const Packet pAlphaImag 
)

Definition at line 2270 of file MatrixProduct.h.

◆ gemm_complex_unrolled_col_iteration()

template<int unroll_factor, typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE void Eigen::internal::gemm_complex_unrolled_col_iteration ( const DataMapper &  res,
const Scalar lhs_base,
const Scalar rhs_base,
Index  depth,
Index  strideA,
Index  offsetA,
Index  strideB,
Index row,
Index  col,
Index  remaining_cols,
const Packet pAlphaReal,
const Packet pAlphaImag 
)

Definition at line 2216 of file MatrixProduct.h.

◆ gemm_complex_unrolled_iteration()

template<int unroll_factor, typename Scalar , typename Packet , typename Packetc , typename DataMapper , typename Index , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE void Eigen::internal::gemm_complex_unrolled_iteration ( const DataMapper &  res,
const Scalar lhs_base,
const Scalar rhs_base,
Index  depth,
Index  strideA,
Index  offsetA,
Index  strideB,
Index row,
Index  col,
const Packet pAlphaReal,
const Packet pAlphaImag 
)

Definition at line 2163 of file MatrixProduct.h.

◆ gemm_complex_unrolled_MMA_iteration()

template<int unroll_factor, typename Scalar , typename Packet , typename Packetc , typename RhsPacket , typename DataMapper , typename Index , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_STRONG_INLINE void Eigen::internal::gemm_complex_unrolled_MMA_iteration ( const DataMapper &  res,
const Scalar lhs_base,
const Scalar rhs_base,
Index  depth,
Index  strideA,
Index  offsetA,
Index  strideB,
Index row,
Index  col,
const Packet pAlphaReal,
const Packet pAlphaImag 
)

Definition at line 493 of file MatrixProductMMA.h.

◆ gemm_complexMMA()

template<typename LhsScalar , typename RhsScalar , typename Scalarc , typename Scalar , typename Index , typename Packet , typename Packetc , typename RhsPacket , typename DataMapper , const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
void Eigen::internal::gemm_complexMMA ( const DataMapper &  res,
const LhsScalar *  blockAc,
const RhsScalar *  blockBc,
Index  rows,
Index  depth,
Index  cols,
Scalarc  alpha,
Index  strideA,
Index  strideB,
Index  offsetA,
Index  offsetB 
)

Definition at line 541 of file MatrixProductMMA.h.

◆ gemm_extra_col()

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

Definition at line 1320 of file MatrixProduct.h.

◆ gemm_extra_row()

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

Definition at line 1383 of file MatrixProduct.h.

◆ gemm_unrolled_col()

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

Definition at line 1634 of file MatrixProduct.h.

◆ gemm_unrolled_col_iteration()

template<int unroll_factor, typename Scalar , typename Packet , typename DataMapper , typename Index , const Index accCols>
EIGEN_STRONG_INLINE void Eigen::internal::gemm_unrolled_col_iteration ( const DataMapper &  res,
const Scalar lhs_base,
const Scalar rhs_base,
Index  depth,
Index  strideA,
Index  offsetA,
Index row,
Index  col,
Index  remaining_cols,
const Packet pAlpha 
)

Definition at line 1597 of file MatrixProduct.h.

◆ gemm_unrolled_iteration()

template<int unroll_factor, typename Scalar , typename Packet , typename DataMapper , typename Index , const Index accRows, const Index accCols>
EIGEN_STRONG_INLINE void Eigen::internal::gemm_unrolled_iteration ( const DataMapper &  res,
const Scalar lhs_base,
const Scalar rhs_base,
Index  depth,
Index  strideA,
Index  offsetA,
Index row,
Index  col,
const Packet pAlpha 
)

Definition at line 1561 of file MatrixProduct.h.

◆ gemm_unrolled_MMA_iteration()

template<int unroll_factor, typename Scalar , typename Packet , typename RhsPacket , typename DataMapper , typename Index , const Index accRows, const Index accCols>
EIGEN_STRONG_INLINE void Eigen::internal::gemm_unrolled_MMA_iteration ( const DataMapper &  res,
const Scalar lhs_base,
const Scalar rhs_base,
Index  depth,
Index  strideA,
Index  offsetA,
Index row,
Index  col,
const Packet pAlpha 
)

Definition at line 247 of file MatrixProductMMA.h.

◆ gemmMMA()

template<typename Scalar , typename Index , typename Packet , typename RhsPacket , typename DataMapper , const Index accRows, const Index accCols>
void Eigen::internal::gemmMMA ( const DataMapper &  res,
const Scalar blockA,
const Scalar blockB,
Index  rows,
Index  depth,
Index  cols,
Scalar  alpha,
Index  strideA,
Index  strideB,
Index  offsetA,
Index  offsetB 
)

Definition at line 282 of file MatrixProductMMA.h.

◆ 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

Definition at line 210 of file InverseImpl.h.

◆ generic_expm1()

template<typename Packet >
Packet Eigen::internal::generic_expm1 ( const Packet x)

Definition at line 408 of file GenericPacketMathFunctions.h.

◆ generic_fast_erf_float()

template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T Eigen::internal::generic_fast_erf_float ( const T a_x)

Definition at line 304 of file SpecialFunctionsImpl.h.

◆ generic_fast_tanh_float()

template<typename T >
T Eigen::internal::generic_fast_tanh_float ( const T a_x)

Definition at line 29 of file MathFunctionsImpl.h.

◆ generic_ndtri()

template<typename T , typename ScalarType >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::internal::generic_ndtri ( const T a)

Definition at line 621 of file SpecialFunctionsImpl.h.

◆ generic_ndtri_gt_exp_neg_two()

template<typename T , typename ScalarType >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T Eigen::internal::generic_ndtri_gt_exp_neg_two ( const T b)

Definition at line 516 of file SpecialFunctionsImpl.h.

◆ generic_ndtri_lt_exp_neg_two()

template<typename T , typename ScalarType >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T Eigen::internal::generic_ndtri_lt_exp_neg_two ( const T b,
const T should_flipsign 
)

Definition at line 549 of file SpecialFunctionsImpl.h.

◆ generic_plog1p()

template<typename Packet >
Packet Eigen::internal::generic_plog1p ( const Packet x)

Definition at line 392 of file GenericPacketMathFunctions.h.

◆ generic_pow()

template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::generic_pow ( const Packet x,
const Packet y 
)

Definition at line 1449 of file GenericPacketMathFunctions.h.

◆ generic_pow_impl()

template<typename Packet >
EIGEN_STRONG_INLINE Packet Eigen::internal::generic_pow_impl ( const Packet x,
const Packet y 
)

Definition at line 1398 of file GenericPacketMathFunctions.h.

◆ get_runtime_reshape_size() [1/2]

template<typename SizeType >
Index Eigen::internal::get_runtime_reshape_size ( SizeType  size,
Index  ,
Index   
)

Definition at line 27 of file ReshapedHelper.h.

◆ get_runtime_reshape_size() [2/2]

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

Definition at line 38 of file ReshapedHelper.h.

◆ get_runtime_value() [1/2]

template<typename T >
EIGEN_DEVICE_FUNC Index Eigen::internal::get_runtime_value ( const T x)

Definition at line 156 of file IntegralConstant.h.

◆ get_runtime_value() [2/2]

template<int N>
EIGEN_DEVICE_FUNC Index Eigen::internal::get_runtime_value ( FixedInt< N *)()

Definition at line 158 of file IntegralConstant.h.

◆ getAdjointVal()

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

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

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

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

Definition at line 120 of file MatrixProduct.h.

◆ GetMarketLine() [1/6]

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

Definition at line 22 of file MarketIO.h.

◆ GetMarketLine() [2/6]

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

Definition at line 28 of file MarketIO.h.

◆ GetMarketLine() [3/6]

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

Definition at line 31 of file MarketIO.h.

◆ GetMarketLine() [4/6]

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

Definition at line 34 of file MarketIO.h.

◆ GetMarketLine() [5/6]

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

Definition at line 37 of file MarketIO.h.

◆ GetMarketLine() [6/6]

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

Definition at line 41 of file MarketIO.h.

◆ GetVectorElt() [1/2]

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

Definition at line 50 of file MarketIO.h.

◆ GetVectorElt() [2/2]

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

Definition at line 57 of file MarketIO.h.

◆ gmres()

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

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

Parameters:

Parameters
matmatrix of linear system of equations
rhsright hand side vector of linear system of equations
xon input: initial guess, on output: solution
precondpreconditioner used
iterson input: maximum number of iterations to perform on output: number of iterations performed
restartnumber of iterations for a restart
tol_erroron input: relative residual tolerance on output: residuum achieved
See also
IterativeMethods::bicgstab()

For references, please see:

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

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

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

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

Definition at line 56 of file GMRES.h.

◆ h_array_apply()

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

Definition at line 442 of file CXX11Meta.h.

◆ h_array_apply_and_reduce()

template<typename Reducer , typename Op , typename A , std::size_t N, int... n>
constexpr EIGEN_STRONG_INLINE auto Eigen::internal::h_array_apply_and_reduce ( array< A, N arr,
numeric_list< int, n... >   
) -> decltype(reduce<Reducer, typename id_numeric<int,n,decltype(Op::run(A()))>::type...>::run(Op::run(array_get<n>(arr))...))

Definition at line 456 of file CXX11Meta.h.

◆ h_array_reverse()

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

Definition at line 338 of file CXX11Meta.h.

◆ h_array_zip()

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

Definition at line 414 of file CXX11Meta.h.

◆ h_array_zip_and_reduce()

template<typename Reducer , typename Op , typename A , typename B , std::size_t N, int... n>
constexpr EIGEN_STRONG_INLINE auto Eigen::internal::h_array_zip_and_reduce ( array< A, N a,
array< B, N b,
numeric_list< int, n... >   
) -> decltype(reduce<Reducer, typename id_numeric<int,n,decltype(Op::run(A(), B()))>::type...>::run(Op::run(array_get<n>(a), array_get<n>(b))...))

Definition at line 428 of file CXX11Meta.h.

◆ half2float() [1/2]

EIGEN_STRONG_INLINE Packet8f Eigen::internal::half2float ( const Packet8h a)

Definition at line 988 of file AVX/PacketMath.h.

◆ half2float() [2/2]

EIGEN_STRONG_INLINE Packet16f Eigen::internal::half2float ( const Packet16h a)

Definition at line 1428 of file AVX512/PacketMath.h.

◆ handmade_aligned_free()

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

Definition at line 114 of file Memory.h.

◆ handmade_aligned_malloc()

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

Definition at line 100 of file Memory.h.

◆ handmade_aligned_realloc()

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

Definition at line 127 of file Memory.h.

◆ 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 
)

Definition at line 267 of file HouseholderQR.h.

◆ idrs()

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

Definition at line 59 of file IDRS.h.

◆ igamma_num_iterations()

template<typename Scalar , IgammaComputationMode mode>
EIGEN_DEVICE_FUNC int Eigen::internal::igamma_num_iterations ( )

Definition at line 746 of file SpecialFunctionsImpl.h.

◆ ignore_unused_variable()

template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ignore_unused_variable ( const T )

Definition at line 1073 of file Macros.h.

◆ index_known_statically()

template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool Eigen::internal::index_known_statically ( Index  i)
static

Definition at line 690 of file TensorIndexList.h.

◆ index_pair_first_statically_eq()

template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool Eigen::internal::index_pair_first_statically_eq ( Index  i,
Index  value 
)
static

Definition at line 725 of file TensorIndexList.h.

◆ index_pair_second_statically_eq()

template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool Eigen::internal::index_pair_second_statically_eq ( Index  i,
Index  value 
)
static

Definition at line 730 of file TensorIndexList.h.

◆ index_statically_eq()

template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool Eigen::internal::index_statically_eq ( Index  i,
Index  value 
)
static

Definition at line 705 of file TensorIndexList.h.

◆ index_statically_gt()

template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool Eigen::internal::index_statically_gt ( Index  i,
Index  value 
)
static

Definition at line 715 of file TensorIndexList.h.

◆ index_statically_lt()

template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool Eigen::internal::index_statically_lt ( Index  i,
Index  value 
)
static

Definition at line 720 of file TensorIndexList.h.

◆ index_statically_ne()

template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool Eigen::internal::index_statically_ne ( Index  i,
Index  value 
)
static

Definition at line 710 of file TensorIndexList.h.

◆ indices_statically_known_to_increase()

template<typename T >
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bool Eigen::internal::indices_statically_known_to_increase ( )
static

Definition at line 700 of file TensorIndexList.h.

◆ instantiate_by_c_array()

template<class InstType , typename ArrType , std::size_t N, bool Reverse = false>
InstType Eigen::internal::instantiate_by_c_array ( ArrType *  arr)

Definition at line 528 of file CXX11Meta.h.

◆ intersect_helper()

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

Definition at line 19 of file BVAlgorithms.h.

◆ is_same_dense() [1/2]

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

Definition at line 695 of file XprHelper.h.

◆ is_same_dense() [2/2]

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

Definition at line 702 of file XprHelper.h.

◆ 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

Definition at line 1947 of file Eigen/src/Core/MathFunctions.h.

◆ 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

Definition at line 1954 of file Eigen/src/Core/MathFunctions.h.

◆ isfinite_impl() [1/3]

template<typename T >
EIGEN_DEVICE_FUNC internal::enable_if<internal::is_integral<T>::value,bool>::type Eigen::internal::isfinite_impl ( const T )

Definition at line 978 of file Eigen/src/Core/MathFunctions.h.

◆ isfinite_impl() [2/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)

Definition at line 983 of file Eigen/src/Core/MathFunctions.h.

◆ isfinite_impl() [3/3]

template<typename T >
EIGEN_DEVICE_FUNC bool Eigen::internal::isfinite_impl ( const std::complex< T > &  x)

Definition at line 1852 of file Eigen/src/Core/MathFunctions.h.

◆ isinf_impl() [1/3]

template<typename T >
EIGEN_DEVICE_FUNC internal::enable_if<internal::is_integral<T>::value,bool>::type Eigen::internal::isinf_impl ( const T )

Definition at line 973 of file Eigen/src/Core/MathFunctions.h.

◆ isinf_impl() [2/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)

Definition at line 998 of file Eigen/src/Core/MathFunctions.h.

◆ isinf_impl() [3/3]

template<typename T >
EIGEN_DEVICE_FUNC bool Eigen::internal::isinf_impl ( const std::complex< T > &  x)

Definition at line 1864 of file Eigen/src/Core/MathFunctions.h.

◆ 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

Definition at line 1940 of file Eigen/src/Core/MathFunctions.h.

◆ isnan_impl() [1/3]

template<typename T >
EIGEN_DEVICE_FUNC internal::enable_if<internal::is_integral<T>::value,bool>::type Eigen::internal::isnan_impl ( const T )

Definition at line 968 of file Eigen/src/Core/MathFunctions.h.

◆ isnan_impl() [2/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)

Definition at line 1013 of file Eigen/src/Core/MathFunctions.h.

◆ isnan_impl() [3/3]

template<typename T >
EIGEN_DEVICE_FUNC bool Eigen::internal::isnan_impl ( const std::complex< T > &  x)

Definition at line 1858 of file Eigen/src/Core/MathFunctions.h.

◆ 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 
)

Definition at line 28 of file LeastSquareConjugateGradient.h.

◆ 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

Definition at line 240 of file LLT.h.

◆ lmpar()

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

Definition at line 6 of file lmpar.h.

◆ lmpar2() [1/2]

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

Definition at line 20 of file LMpar.h.

◆ lmpar2() [2/2]

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

Definition at line 164 of file lmpar.h.

◆ lmqrsolv() [1/2]

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

Definition at line 23 of file LMqrsolv.h.

◆ lmqrsolv() [2/2]

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

Definition at line 102 of file LMqrsolv.h.

◆ loadPacketRemaining() [1/2]

template<typename Scalar , typename Packet , typename Index >
EIGEN_ALWAYS_INLINE void Eigen::internal::loadPacketRemaining ( const Scalar lhs,
Packet lhsV,
Index  remaining_rows 
)

Definition at line 1035 of file MatrixProduct.h.

◆ loadPacketRemaining() [2/2]

template<typename Scalar , typename Packet , typename Index , bool LhsIsReal>
EIGEN_ALWAYS_INLINE void Eigen::internal::loadPacketRemaining ( const Scalar lhs_ptr,
const Scalar lhs_ptr_imag,
Packet lhsV,
Packet lhsVi,
Index  remaining_rows 
)

Definition at line 1088 of file MatrixProduct.h.

◆ loadQuadToDoublePacket() [1/2]

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

Definition at line 725 of file products/GeneralBlockPanelKernel.h.

◆ loadQuadToDoublePacket() [2/2]

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

Definition at line 733 of file products/GeneralBlockPanelKernel.h.

◆ LUnumTempV()

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

Definition at line 39 of file SparseLU_Memory.h.

◆ LUTempSpace()

template<typename Scalar >
Index Eigen::internal::LUTempSpace ( Index m,
Index w 
)
inline

Definition at line 45 of file SparseLU_Memory.h.

◆ main_igamma_term()

template<typename Scalar >
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar Eigen::internal::main_igamma_term ( Scalar  a,
Scalar  x 
)
static

Definition at line 733 of file SpecialFunctionsImpl.h.

◆ 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 
)

Definition at line 51 of file BlockHouseholder.h.

◆ make_coherent()

template<typename A , typename B >
void Eigen::internal::make_coherent ( const A a,
const B b 
)

Definition at line 24 of file AutoDiffScalar.h.

◆ make_coherent_expression() [1/3]

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

Definition at line 457 of file AutoDiffScalar.h.

◆ make_coherent_expression() [2/3]

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

Definition at line 464 of file AutoDiffScalar.h.

◆ make_coherent_expression() [3/3]

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

Definition at line 471 of file AutoDiffScalar.h.

◆ makeIndexedViewCompatible() [1/4]

template<typename T , typename Q >
const T& Eigen::internal::makeIndexedViewCompatible ( const T x,
Index  ,
Q   
)

Definition at line 91 of file IndexedViewHelper.h.

◆ makeIndexedViewCompatible() [2/4]

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

Definition at line 129 of file IndexedViewHelper.h.

◆ makeIndexedViewCompatible() [3/4]

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

Definition at line 156 of file IndexedViewHelper.h.

◆ makeIndexedViewCompatible() [4/4]

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

Definition at line 366 of file ArithmeticSequence.h.

◆ manage_caching_sizes()

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

Definition at line 86 of file products/GeneralBlockPanelKernel.h.

◆ manage_caching_sizes_helper()

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

Definition at line 29 of file products/GeneralBlockPanelKernel.h.

◆ manage_multi_threading()

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

Definition at line 22 of file Parallelizer.h.

◆ 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

Definition at line 298 of file SuperLUSupport.h.

◆ matrix_exp_compute() [1/2]

template<typename ArgType , typename ResultType >
void Eigen::internal::matrix_exp_compute ( const ArgType &  arg,
ResultType &  result,
true_type   
)

Definition at line 355 of file MatrixExponential.h.

◆ matrix_exp_compute() [2/2]

template<typename ArgType , typename ResultType >
void Eigen::internal::matrix_exp_compute ( const ArgType &  arg,
ResultType &  result,
false_type   
)

Definition at line 375 of file MatrixExponential.h.

◆ matrix_exp_pade13()

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

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

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

Definition at line 143 of file MatrixExponential.h.

◆ matrix_exp_pade3()

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

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

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

Definition at line 65 of file MatrixExponential.h.

◆ matrix_exp_pade5()

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

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

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

Definition at line 82 of file MatrixExponential.h.

◆ matrix_exp_pade7()

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

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

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

Definition at line 100 of file MatrixExponential.h.

◆ matrix_exp_pade9()

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

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

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

Definition at line 121 of file MatrixExponential.h.

◆ matrix_function_compute_above_diagonal()

template<typename MatrixType , typename VectorType >
void Eigen::internal::matrix_function_compute_above_diagonal ( const MatrixType T,
const VectorType blockStart,
const VectorType clusterSize,
MatrixType fT 
)

Compute part of matrix function above block diagonal.

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

Definition at line 323 of file MatrixFunction.h.

◆ matrix_function_compute_block_atomic()

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

Compute block diagonal part of matrix function.

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

Definition at line 242 of file MatrixFunction.h.

◆ matrix_function_compute_block_start()

template<typename VectorType >
void Eigen::internal::matrix_function_compute_block_start ( const VectorType clusterSize,
VectorType blockStart 
)

Compute start of each block using clusterSize.

Definition at line 176 of file MatrixFunction.h.

◆ matrix_function_compute_cluster_size()

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

Compute size of each cluster given a partitioning.

Definition at line 163 of file MatrixFunction.h.

◆ matrix_function_compute_map()

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

Compute mapping of eigenvalue indices to cluster indices.

Definition at line 187 of file MatrixFunction.h.

◆ matrix_function_compute_mu()

template<typename MatrixType >
NumTraits<typename MatrixType::Scalar>::Real Eigen::internal::matrix_function_compute_mu ( const MatrixType A)

Definition at line 53 of file MatrixFunction.h.

◆ matrix_function_compute_permutation()

template<typename DynVectorType , typename VectorType >
void Eigen::internal::matrix_function_compute_permutation ( const DynVectorType &  blockStart,
const DynVectorType &  eivalToCluster,
VectorType permutation 
)

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

Definition at line 203 of file MatrixFunction.h.

◆ matrix_function_find_cluster()

template<typename Index , typename ListOfClusters >
ListOfClusters::iterator Eigen::internal::matrix_function_find_cluster ( Index  key,
ListOfClusters &  clusters 
)

Find cluster in clusters containing some value.

Parameters
[in]keyValue to find
Returns
Iterator to cluster containing key, or clusters.end() if no cluster in m_clusters contains key.

Definition at line 108 of file MatrixFunction.h.

◆ matrix_function_partition_eigenvalues()

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

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

Parameters
[in]eivalsEigenvalues
[out]clustersResulting partition of eigenvalues

The partition satisfies the following two properties:

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

in the same cluster.

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

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

Definition at line 131 of file MatrixFunction.h.

◆ matrix_function_permute_schur()

template<typename VectorType , typename MatrixType >
void Eigen::internal::matrix_function_permute_schur ( VectorType permutation,
MatrixType U,
MatrixType T 
)

Permute Schur decomposition in U and T according to permutation.

Definition at line 216 of file MatrixFunction.h.

◆ matrix_function_solve_triangular_sylvester()

template<typename MatrixType >
MatrixType Eigen::internal::matrix_function_solve_triangular_sylvester ( const MatrixType A,
const MatrixType B,
const MatrixType C 
)

Solve a triangular Sylvester equation AX + XB = C.

Parameters
[in]Athe matrix A; should be square and upper triangular
[in]Bthe matrix B; should be square and upper triangular
[in]Cthe matrix C; should have correct size.
Returns
the solution X.

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

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

This can be re-arranged to yield:

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

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

Definition at line 274 of file MatrixFunction.h.

◆ matrix_log_compute_2x2()

template<typename MatrixType >
void Eigen::internal::matrix_log_compute_2x2 ( const MatrixType A,
MatrixType result 
)

Compute logarithm of 2x2 triangular matrix.

Definition at line 37 of file MatrixLogarithm.h.

◆ matrix_log_compute_big()

template<typename MatrixType >
void Eigen::internal::matrix_log_compute_big ( const MatrixType A,
MatrixType result 
)

Compute logarithm of triangular matrices with size > 2.

This uses a inverse scale-and-square algorithm.

Definition at line 225 of file MatrixLogarithm.h.

◆ matrix_log_compute_pade()

template<typename MatrixType >
void Eigen::internal::matrix_log_compute_pade ( MatrixType result,
const MatrixType T,
int  degree 
)

Definition at line 132 of file MatrixLogarithm.h.

◆ matrix_log_get_pade_degree() [1/3]

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

Definition at line 71 of file MatrixLogarithm.h.

◆ matrix_log_get_pade_degree() [2/3]

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

Definition at line 85 of file MatrixLogarithm.h.

◆ matrix_log_get_pade_degree() [3/3]

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

Definition at line 99 of file MatrixLogarithm.h.

◆ matrix_sqrt_quasi_triangular_1x1_off_diagonal_block()

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

Definition at line 35 of file MatrixSquareRoot.h.

◆ matrix_sqrt_quasi_triangular_1x2_off_diagonal_block()

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

Definition at line 44 of file MatrixSquareRoot.h.

◆ matrix_sqrt_quasi_triangular_2x1_off_diagonal_block()

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

Definition at line 57 of file MatrixSquareRoot.h.

◆ matrix_sqrt_quasi_triangular_2x2_diagonal_block()

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

Definition at line 20 of file MatrixSquareRoot.h.

◆ matrix_sqrt_quasi_triangular_2x2_off_diagonal_block()

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

Definition at line 104 of file MatrixSquareRoot.h.

◆ matrix_sqrt_quasi_triangular_diagonal()

template<typename MatrixType , typename ResultType >
void Eigen::internal::matrix_sqrt_quasi_triangular_diagonal ( const MatrixType T,
ResultType &  sqrtT 
)

Definition at line 120 of file MatrixSquareRoot.h.

◆ matrix_sqrt_quasi_triangular_off_diagonal()

template<typename MatrixType , typename ResultType >
void Eigen::internal::matrix_sqrt_quasi_triangular_off_diagonal ( const MatrixType T,
ResultType &  sqrtT 
)

Definition at line 139 of file MatrixSquareRoot.h.

◆ matrix_sqrt_quasi_triangular_solve_auxiliary_equation()

template<typename MatrixType >
void Eigen::internal::matrix_sqrt_quasi_triangular_solve_auxiliary_equation ( MatrixType X,
const MatrixType A,
const MatrixType B,
const MatrixType C 
)

Definition at line 70 of file MatrixSquareRoot.h.

◆ MICRO_COMPLEX_EXTRA_COL()

template<typename Scalar , typename Packet , typename Index , const Index accRows, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_ALWAYS_INLINE void Eigen::internal::MICRO_COMPLEX_EXTRA_COL ( const Scalar *&  lhs_ptr_real,
const Scalar *&  lhs_ptr_imag,
const Scalar *&  rhs_ptr_real,
const Scalar *&  rhs_ptr_imag,
PacketBlock< Packet, 1 > &  accReal,
PacketBlock< Packet, 1 > &  accImag,
Index  remaining_rows,
Index  remaining_cols 
)

Definition at line 1794 of file MatrixProduct.h.

◆ MICRO_COMPLEX_EXTRA_ROW()

template<typename Scalar , typename Packet , typename Index , const Index accRows, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_ALWAYS_INLINE void Eigen::internal::MICRO_COMPLEX_EXTRA_ROW ( const Scalar *&  lhs_ptr_real,
const Scalar *&  lhs_ptr_imag,
const Scalar *&  rhs_ptr_real,
const Scalar *&  rhs_ptr_imag,
PacketBlock< Packet, 4 > &  accReal,
PacketBlock< Packet, 4 > &  accImag,
Index  remaining_rows 
)

Definition at line 1893 of file MatrixProduct.h.

◆ MICRO_EXTRA_COL()

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

Definition at line 1305 of file MatrixProduct.h.

◆ MICRO_EXTRA_ROW()

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

Definition at line 1369 of file MatrixProduct.h.

◆ minimize_helper()

template<typename BVH , typename Minimizer >
Minimizer::Scalar Eigen::internal::minimize_helper ( const BVH &  tree,
Minimizer &  minimizer,
typename BVH::Index  root,
typename Minimizer::Scalar  minimum 
)

Definition at line 149 of file BVAlgorithms.h.

◆ minimum_degree_ordering()

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

Definition at line 84 of file Amd.h.

◆ minres()

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

Definition at line 32 of file MINRES.h.

◆ negate()

template<typename T >
T Eigen::internal::negate ( const T x)

Definition at line 24 of file packetmath_test_shared.h.

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

Definition at line 130 of file SparseColEtree.h.

◆ omega()

template<typename Vector , typename RealScalar >
Vector::Scalar Eigen::internal::omega ( const Vector &  t,
const Vector &  s,
RealScalar  angle 
)

Definition at line 36 of file IDRS.h.

◆ operator!=()

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

Definition at line 86 of file TensorUInt128.h.

◆ operator*()

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

Definition at line 136 of file TensorUInt128.h.

◆ operator+()

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

Definition at line 113 of file TensorUInt128.h.

◆ operator-()

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

Definition at line 124 of file TensorUInt128.h.

◆ operator/() [1/2]

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

Definition at line 211 of file TensorUInt128.h.

◆ operator/() [2/2]

template<typename T , bool div_gt_one>
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T Eigen::internal::operator/ ( const T numerator,
const TensorIntDivisor< T, div_gt_one > &  divisor 
)
static

Definition at line 255 of file TensorIntDiv.h.

◆ operator<()

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

Definition at line 103 of file TensorUInt128.h.

◆ operator<<() [1/15]

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

Definition at line 95 of file MSA/Complex.h.

◆ operator<<() [2/15]

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

Definition at line 317 of file MSA/Complex.h.

◆ operator<<() [3/15]

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

Definition at line 371 of file AltiVec/PacketMath.h.

◆ operator<<() [4/15]

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

Definition at line 383 of file AltiVec/PacketMath.h.

◆ operator<<() [5/15]

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

Definition at line 395 of file AltiVec/PacketMath.h.

◆ operator<<() [6/15]

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

Definition at line 406 of file AltiVec/PacketMath.h.

◆ operator<<() [7/15]

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

Definition at line 413 of file MSA/Complex.h.

◆ operator<<() [8/15]

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

Definition at line 417 of file AltiVec/PacketMath.h.

◆ operator<<() [9/15]

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

Definition at line 626 of file MSA/Complex.h.

◆ operator<<() [10/15]

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

Definition at line 674 of file MSA/PacketMath.h.

◆ operator<<() [11/15]

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

Definition at line 698 of file MSA/PacketMath.h.

◆ operator<<() [12/15]

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

Definition at line 828 of file MSA/PacketMath.h.

◆ operator<<() [13/15]

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

Definition at line 833 of file MSA/PacketMath.h.

◆ operator<<() [14/15]

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

Definition at line 838 of file MSA/PacketMath.h.

◆ operator<<() [15/15]

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

Definition at line 1148 of file MSA/PacketMath.h.

◆ operator==()

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

Definition at line 79 of file TensorUInt128.h.

◆ operator>=()

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

Definition at line 93 of file TensorUInt128.h.

◆ ordering_helper_at_plus_a()

template<typename MatrixType >
void Eigen::internal::ordering_helper_at_plus_a ( const MatrixType A,
MatrixType symmat 
)

◆ outer_product_selector_run() [1/2]

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

Definition at line 272 of file ProductEvaluators.h.

◆ outer_product_selector_run() [2/2]

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

Definition at line 285 of file ProductEvaluators.h.

◆ p2ui_CONJ_XOR()

uint32x2_t Eigen::internal::p2ui_CONJ_XOR ( )
inline

Definition at line 30 of file NEON/Complex.h.

◆ p4ui_CONJ_XOR()

uint32x4_t Eigen::internal::p4ui_CONJ_XOR ( )
inline

Definition at line 18 of file NEON/Complex.h.

◆ pabs() [1/33]

template<>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::pabs ( const PacketXi &  a)

Definition at line 292 of file SVE/PacketMath.h.

◆ pabs() [2/33]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pabs ( const Packet a)
inline

Definition at line 535 of file GenericPacketMath.h.

◆ pabs() [3/33]

template<>
EIGEN_DEVICE_FUNC unsigned int Eigen::internal::pabs ( const unsigned int a)
inline

Definition at line 537 of file GenericPacketMath.h.

◆ pabs() [4/33]

template<>
EIGEN_DEVICE_FUNC unsigned long Eigen::internal::pabs ( const unsigned long &  a)
inline

Definition at line 539 of file GenericPacketMath.h.

◆ pabs() [5/33]

template<>
EIGEN_DEVICE_FUNC unsigned long long Eigen::internal::pabs ( const unsigned long long &  a)
inline

Definition at line 541 of file GenericPacketMath.h.

◆ pabs() [6/33]

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::pabs ( const PacketXf &  a)

Definition at line 658 of file SVE/PacketMath.h.

◆ pabs() [7/33]

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pabs ( const Packet8f a)

Definition at line 725 of file AVX/PacketMath.h.

◆ pabs() [8/33]

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pabs ( const Packet4d a)

Definition at line 730 of file AVX/PacketMath.h.

◆ pabs() [9/33]

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pabs ( const Packet16f a)

Definition at line 885 of file AVX512/PacketMath.h.

◆ pabs() [10/33]

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pabs ( const Packet8d a)

Definition at line 891 of file AVX512/PacketMath.h.

◆ pabs() [11/33]

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::pabs ( const Packet8h a)

Definition at line 983 of file AVX/PacketMath.h.

◆ pabs() [12/33]

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pabs ( const Packet2d a)

Definition at line 1075 of file MSA/PacketMath.h.

◆ pabs() [13/33]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pabs ( const Packet4f a)

Definition at line 1176 of file AltiVec/PacketMath.h.

◆ pabs() [14/33]

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pabs ( const Packet4i a)

Definition at line 1177 of file AltiVec/PacketMath.h.

◆ pabs() [15/33]

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::pabs ( const Packet8s a)

Definition at line 1178 of file AltiVec/PacketMath.h.

◆ pabs() [16/33]

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::pabs ( const Packet8us a)

Definition at line 1179 of file AltiVec/PacketMath.h.

◆ pabs() [17/33]

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::pabs ( const Packet16c a)

Definition at line 1180 of file AltiVec/PacketMath.h.

◆ pabs() [18/33]

template<>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pabs ( const Packet16uc a)

Definition at line 1181 of file AltiVec/PacketMath.h.

◆ pabs() [19/33]

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pabs ( const Packet8bf a)

Definition at line 1182 of file AltiVec/PacketMath.h.

◆ pabs() [20/33]

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::pabs ( const Packet16h a)

Definition at line 1490 of file AVX512/PacketMath.h.

◆ pabs() [21/33]

template<>
EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pabs ( const Packet16bf a)

Definition at line 2067 of file AVX512/PacketMath.h.

◆ pabs() [22/33]

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::pabs ( const Packet2f a)

Definition at line 2349 of file NEON/PacketMath.h.

◆ pabs() [23/33]

template<>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::pabs ( const Packet8c a)

Definition at line 2353 of file NEON/PacketMath.h.

◆ pabs() [24/33]

template<>
EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pabs ( const Packet4uc a)

Definition at line 2355 of file NEON/PacketMath.h.

◆ pabs() [25/33]

template<>
EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pabs ( const Packet8uc a)

Definition at line 2356 of file NEON/PacketMath.h.

◆ pabs() [26/33]

template<>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::pabs ( const Packet4s a)

Definition at line 2358 of file NEON/PacketMath.h.

◆ pabs() [27/33]

template<>
EIGEN_STRONG_INLINE Packet4us Eigen::internal::pabs ( const Packet4us a)

Definition at line 2360 of file NEON/PacketMath.h.

◆ pabs() [28/33]

template<>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::pabs ( const Packet2i a)

Definition at line 2362 of file NEON/PacketMath.h.

◆ pabs() [29/33]

template<>
EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pabs ( const Packet2ui a)

Definition at line 2364 of file NEON/PacketMath.h.

◆ pabs() [30/33]

template<>
EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pabs ( const Packet4ui a)

Definition at line 2365 of file NEON/PacketMath.h.

◆ pabs() [31/33]

template<>
EIGEN_STRONG_INLINE Packet2l Eigen::internal::pabs ( const Packet2l a)

Definition at line 2366 of file NEON/PacketMath.h.

◆ pabs() [32/33]

template<>
EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pabs ( const Packet2ul a)

Definition at line 2375 of file NEON/PacketMath.h.

◆ pabs() [33/33]

template<>
EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pabs ( const Packet4bf a)

Definition at line 3456 of file NEON/PacketMath.h.

◆ pabs< Packet2d >()

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

◆ pabs< Packet4c >()

Definition at line 2351 of file NEON/PacketMath.h.

◆ pabs< Packet4f >()

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

◆ pabs< Packet4i >()

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

◆ pabsdiff()

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pabsdiff ( const Packet a,
const Packet b 
)
inline

Definition at line 595 of file GenericPacketMath.h.

◆ pabsdiff< Packet16c >()

Definition at line 1151 of file NEON/PacketMath.h.

◆ pabsdiff< Packet16uc >()

Definition at line 1161 of file NEON/PacketMath.h.

◆ pabsdiff< Packet2f >()

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

Definition at line 1139 of file NEON/PacketMath.h.

◆ pabsdiff< Packet2i >()

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

Definition at line 1171 of file NEON/PacketMath.h.

◆ pabsdiff< Packet2ui >()

Definition at line 1175 of file NEON/PacketMath.h.

◆ pabsdiff< Packet4bf >()

Definition at line 3596 of file NEON/PacketMath.h.

◆ pabsdiff< Packet4c >()

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

Definition at line 1143 of file NEON/PacketMath.h.

◆ pabsdiff< Packet4f >()

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

Definition at line 1141 of file NEON/PacketMath.h.

◆ pabsdiff< Packet4i >()

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

Definition at line 1173 of file NEON/PacketMath.h.

◆ pabsdiff< Packet4s >()

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

Definition at line 1163 of file NEON/PacketMath.h.

◆ pabsdiff< Packet4uc >()

Definition at line 1153 of file NEON/PacketMath.h.

◆ pabsdiff< Packet4ui >()

Definition at line 1177 of file NEON/PacketMath.h.

◆ pabsdiff< Packet4us >()

Definition at line 1167 of file NEON/PacketMath.h.

◆ pabsdiff< Packet8c >()

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

Definition at line 1149 of file NEON/PacketMath.h.

◆ pabsdiff< Packet8s >()

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

Definition at line 1165 of file NEON/PacketMath.h.

◆ pabsdiff< Packet8uc >()

Definition at line 1159 of file NEON/PacketMath.h.

◆ pabsdiff< Packet8us >()

Definition at line 1169 of file NEON/PacketMath.h.

◆ Pack16To8()

EIGEN_STRONG_INLINE __m128i Eigen::internal::Pack16To8 ( Packet8f  rf)

Definition at line 234 of file AVX/PacketMath.h.

◆ Pack32To16()

EIGEN_STRONG_INLINE __m256i Eigen::internal::Pack32To16 ( Packet16f  rf)

Definition at line 454 of file AVX512/PacketMath.h.

◆ packetwise_redux_empty_value() [1/2]

template<typename PacketType , typename Func >
EIGEN_DEVICE_FUNC PacketType Eigen::internal::packetwise_redux_empty_value ( const Func &  )

Definition at line 57 of file PartialReduxEvaluator.h.

◆ packetwise_redux_empty_value() [2/2]

template<typename PacketType , typename Scalar >
EIGEN_DEVICE_FUNC PacketType Eigen::internal::packetwise_redux_empty_value ( const scalar_product_op< Scalar, Scalar > &  )

Definition at line 62 of file PartialReduxEvaluator.h.

◆ pacos()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pacos ( const Packet a)

Definition at line 768 of file GenericPacketMath.h.

◆ padd() [1/3]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::padd ( const Packet a,
const Packet b 
)
inline

Definition at line 215 of file GenericPacketMath.h.

◆ padd() [2/3]

template<>
EIGEN_DEVICE_FUNC bool Eigen::internal::padd ( const bool &  a,
const bool &  b 
)
inline

Definition at line 218 of file GenericPacketMath.h.

◆ padd() [3/3]

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

Definition at line 689 of file products/GeneralBlockPanelKernel.h.

◆ padd< Packet16b >()

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

Definition at line 293 of file SSE/PacketMath.h.

◆ padd< Packet16bf >()

Definition at line 2073 of file AVX512/PacketMath.h.

◆ padd< Packet16c >()

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

Definition at line 779 of file AltiVec/PacketMath.h.

◆ padd< Packet16f >()

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

Definition at line 259 of file AVX512/PacketMath.h.

◆ padd< Packet16h >()

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

Definition at line 1572 of file AVX512/PacketMath.h.

◆ padd< Packet16i >()

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

Definition at line 269 of file AVX512/PacketMath.h.

◆ padd< Packet16uc >()

Definition at line 780 of file AltiVec/PacketMath.h.

◆ padd< Packet1cd >()

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

Definition at line 470 of file MSA/Complex.h.

◆ padd< Packet1cf >()

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

Definition at line 117 of file NEON/Complex.h.

◆ padd< Packet2cd >()

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

Definition at line 233 of file AVX/Complex.h.

◆ padd< Packet2cf >()

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

Definition at line 164 of file AltiVec/Complex.h.

◆ padd< Packet2d >()

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

Definition at line 880 of file MSA/PacketMath.h.

◆ padd< Packet2f >()

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

Definition at line 805 of file NEON/PacketMath.h.

◆ padd< Packet2i >()

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

Definition at line 827 of file NEON/PacketMath.h.

◆ padd< Packet2l >()

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

Definition at line 831 of file NEON/PacketMath.h.

◆ padd< Packet2ui >()

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

Definition at line 829 of file NEON/PacketMath.h.

◆ padd< Packet2ul >()

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

Definition at line 832 of file NEON/PacketMath.h.

◆ padd< Packet4bf >()

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

Definition at line 3538 of file NEON/PacketMath.h.

◆ padd< Packet4c >()

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

Definition at line 807 of file NEON/PacketMath.h.

◆ padd< Packet4cd >()

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

Definition at line 217 of file AVX512/Complex.h.

◆ padd< Packet4cf >()

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

Definition at line 64 of file AVX/Complex.h.

◆ padd< Packet4d >()

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

Definition at line 263 of file AVX/PacketMath.h.

◆ padd< Packet4f >()

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

Definition at line 774 of file AltiVec/PacketMath.h.

◆ padd< Packet4i >()

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

Definition at line 775 of file AltiVec/PacketMath.h.

◆ padd< Packet4s >()

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

Definition at line 823 of file NEON/PacketMath.h.

◆ padd< Packet4uc >()

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

Definition at line 815 of file NEON/PacketMath.h.

◆ padd< Packet4ui >()

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

Definition at line 776 of file AltiVec/PacketMath.h.

◆ padd< Packet4us >()

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

Definition at line 825 of file NEON/PacketMath.h.

◆ padd< Packet8bf >()

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

Definition at line 1324 of file AltiVec/PacketMath.h.

◆ padd< Packet8c >()

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

Definition at line 813 of file NEON/PacketMath.h.

◆ padd< Packet8cf >()

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

Definition at line 63 of file AVX512/Complex.h.

◆ padd< Packet8d >()

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

Definition at line 264 of file AVX512/PacketMath.h.

◆ padd< Packet8f >()

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

Definition at line 262 of file AVX/PacketMath.h.

◆ padd< Packet8h >()

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

Definition at line 1100 of file AVX/PacketMath.h.

◆ padd< Packet8i >()

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

Definition at line 264 of file AVX/PacketMath.h.

◆ padd< Packet8s >()

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

Definition at line 777 of file AltiVec/PacketMath.h.

◆ padd< Packet8uc >()

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

Definition at line 821 of file NEON/PacketMath.h.

◆ padd< Packet8us >()

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

Definition at line 778 of file AltiVec/PacketMath.h.

◆ padd< PacketXf >()

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

Definition at line 444 of file SVE/PacketMath.h.

◆ padd< PacketXi >()

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

Definition at line 96 of file SVE/PacketMath.h.

◆ paddsub()

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::paddsub ( const Packet a,
const Packet b 
)
inline

Definition at line 545 of file GenericPacketMath.h.

◆ paddsub< Packet2d >()

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

Definition at line 312 of file SSE/PacketMath.h.

◆ paddsub< Packet2f >()

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

Definition at line 864 of file NEON/PacketMath.h.

◆ paddsub< Packet4f >()

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

Definition at line 869 of file NEON/PacketMath.h.

◆ pand() [1/6]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pand ( const Packet a,
const Packet b 
)
inline

Definition at line 407 of file GenericPacketMath.h.

◆ pand() [2/6]

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::pand ( const Packet8h a,
const Packet8h b 
)

Definition at line 1050 of file AVX/PacketMath.h.

◆ pand() [3/6]

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

Definition at line 1396 of file AVX/PacketMath.h.

◆ pand() [4/6]

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::pand ( const Packet16h a,
const Packet16h b 
)

Definition at line 1520 of file AVX512/PacketMath.h.

◆ pand() [5/6]

template<>
EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pand ( const Packet16bf a,
const Packet16bf b 
)

Definition at line 1995 of file AVX512/PacketMath.h.

◆ pand() [6/6]

template<>
EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pand ( const Packet4bf a,
const Packet4bf b 
)

Definition at line 3507 of file NEON/PacketMath.h.

◆ pand< Packet16b >()

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

Definition at line 415 of file SSE/PacketMath.h.

◆ pand< Packet16c >()

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

Definition at line 1473 of file NEON/PacketMath.h.

◆ pand< Packet16f >()

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

Definition at line 557 of file AVX512/PacketMath.h.

◆ pand< Packet16i >()

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

Definition at line 551 of file AVX512/PacketMath.h.

◆ pand< Packet16uc >()

Definition at line 1479 of file NEON/PacketMath.h.

◆ pand< Packet1cd >()

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

Definition at line 505 of file MSA/Complex.h.

◆ pand< Packet1cf >()

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

Definition at line 203 of file NEON/Complex.h.

◆ pand< Packet2cd >()

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

Definition at line 259 of file AVX/Complex.h.

◆ pand< Packet2cf >()

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

Definition at line 169 of file AltiVec/Complex.h.

◆ pand< Packet2d >()

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

Definition at line 939 of file MSA/PacketMath.h.

◆ pand< Packet2f >()

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

Definition at line 1465 of file NEON/PacketMath.h.

◆ pand< Packet2i >()

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

Definition at line 1487 of file NEON/PacketMath.h.

◆ pand< Packet2l >()

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

Definition at line 1493 of file NEON/PacketMath.h.

◆ pand< Packet2ui >()

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

Definition at line 1489 of file NEON/PacketMath.h.

◆ pand< Packet2ul >()

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

Definition at line 1494 of file NEON/PacketMath.h.

◆ pand< Packet4c >()

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

Definition at line 1469 of file NEON/PacketMath.h.

◆ pand< Packet4cd >()

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

Definition at line 238 of file AVX512/Complex.h.

◆ pand< Packet4cf >()

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

Definition at line 91 of file AVX/Complex.h.

◆ pand< Packet4d >()

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

Definition at line 490 of file AVX/PacketMath.h.

◆ pand< Packet4f >()

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

Definition at line 891 of file AltiVec/PacketMath.h.

◆ pand< Packet4i >()

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

Definition at line 892 of file AltiVec/PacketMath.h.

◆ pand< Packet4s >()

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

Definition at line 1481 of file NEON/PacketMath.h.

◆ pand< Packet4uc >()

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

Definition at line 1475 of file NEON/PacketMath.h.

◆ pand< Packet4ui >()

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

Definition at line 893 of file AltiVec/PacketMath.h.

◆ pand< Packet4us >()

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

Definition at line 1483 of file NEON/PacketMath.h.

◆ pand< Packet8bf >()

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

Definition at line 895 of file AltiVec/PacketMath.h.

◆ pand< Packet8c >()

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

Definition at line 1471 of file NEON/PacketMath.h.

◆ pand< Packet8cf >()

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

Definition at line 83 of file AVX512/Complex.h.

◆ pand< Packet8d >()

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

Definition at line 566 of file AVX512/PacketMath.h.

◆ pand< Packet8f >()

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

Definition at line 489 of file AVX/PacketMath.h.

◆ pand< Packet8i >()

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

Definition at line 491 of file AVX/PacketMath.h.

◆ pand< Packet8s >()

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

Definition at line 1482 of file NEON/PacketMath.h.

◆ pand< Packet8uc >()

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

Definition at line 1477 of file NEON/PacketMath.h.

◆ pand< Packet8us >()

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

Definition at line 894 of file AltiVec/PacketMath.h.

◆ pand< PacketXf >()

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

Definition at line 564 of file SVE/PacketMath.h.

◆ pand< PacketXi >()

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

Definition at line 180 of file SVE/PacketMath.h.

◆ pandnot() [1/6]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pandnot ( const Packet a,
const Packet b 
)
inline

Definition at line 431 of file GenericPacketMath.h.

◆ pandnot() [2/6]

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::pandnot ( const Packet8h a,
const Packet8h b 
)

Definition at line 1053 of file AVX/PacketMath.h.

◆ pandnot() [3/6]

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pandnot ( const Packet8bf a,
const Packet8bf b 
)

Definition at line 1399 of file AVX/PacketMath.h.

◆ pandnot() [4/6]

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::pandnot ( const Packet16h a,
const Packet16h b 
)

Definition at line 1523 of file AVX512/PacketMath.h.

◆ pandnot() [5/6]

template<>
EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pandnot ( const Packet16bf a,
const Packet16bf b 
)

Definition at line 2000 of file AVX512/PacketMath.h.

◆ pandnot() [6/6]

template<>
EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pandnot ( const Packet4bf a,
const Packet4bf b 
)

Definition at line 3511 of file NEON/PacketMath.h.

◆ pandnot< Packet16c >()

Definition at line 1571 of file NEON/PacketMath.h.

◆ pandnot< Packet16f >()

Definition at line 635 of file AVX512/PacketMath.h.

◆ pandnot< Packet16i >()

Definition at line 630 of file AVX512/PacketMath.h.

◆ pandnot< Packet16uc >()

Definition at line 1576 of file NEON/PacketMath.h.

◆ pandnot< Packet1cd >()

Definition at line 526 of file MSA/Complex.h.

◆ pandnot< Packet1cf >()

Definition at line 218 of file NEON/Complex.h.

◆ pandnot< Packet2cd >()

Definition at line 262 of file AVX/Complex.h.

◆ pandnot< Packet2cf >()

Definition at line 172 of file AltiVec/Complex.h.

◆ pandnot< Packet2d >()

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

Definition at line 960 of file MSA/PacketMath.h.

◆ pandnot< Packet2f >()

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

Definition at line 1564 of file NEON/PacketMath.h.

◆ pandnot< Packet2i >()

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

Definition at line 1586 of file NEON/PacketMath.h.

◆ pandnot< Packet2l >()

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

Definition at line 1594 of file NEON/PacketMath.h.

◆ pandnot< Packet2ui >()

Definition at line 1590 of file NEON/PacketMath.h.

◆ pandnot< Packet2ul >()

Definition at line 1596 of file NEON/PacketMath.h.

◆ pandnot< Packet4c >()

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

Definition at line 1568 of file NEON/PacketMath.h.

◆ pandnot< Packet4cd >()

Definition at line 241 of file AVX512/Complex.h.

◆ pandnot< Packet4cf >()

Definition at line 94 of file AVX/Complex.h.

◆ pandnot< Packet4d >()

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

Definition at line 520 of file AVX/PacketMath.h.

◆ pandnot< Packet4f >()

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

Definition at line 914 of file AltiVec/PacketMath.h.

◆ pandnot< Packet4i >()

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

Definition at line 915 of file AltiVec/PacketMath.h.

◆ pandnot< Packet4s >()

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

Definition at line 1578 of file NEON/PacketMath.h.

◆ pandnot< Packet4uc >()

Definition at line 1572 of file NEON/PacketMath.h.

◆ pandnot< Packet4ui >()

Definition at line 1592 of file NEON/PacketMath.h.

◆ pandnot< Packet4us >()

Definition at line 1582 of file NEON/PacketMath.h.

◆ pandnot< Packet8c >()

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

Definition at line 1570 of file NEON/PacketMath.h.

◆ pandnot< Packet8cf >()

Definition at line 86 of file AVX512/Complex.h.

◆ pandnot< Packet8d >()

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

Definition at line 643 of file AVX512/PacketMath.h.

◆ pandnot< Packet8f >()

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

Definition at line 519 of file AVX/PacketMath.h.

◆ pandnot< Packet8i >()

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

Definition at line 521 of file AVX/PacketMath.h.

◆ pandnot< Packet8s >()

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

Definition at line 1580 of file NEON/PacketMath.h.

◆ pandnot< Packet8uc >()

Definition at line 1574 of file NEON/PacketMath.h.

◆ pandnot< Packet8us >()

Definition at line 1584 of file NEON/PacketMath.h.

◆ pandnot< PacketXf >()

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

Definition at line 582 of file SVE/PacketMath.h.

◆ pandnot< PacketXi >()

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

Definition at line 198 of file SVE/PacketMath.h.

◆ 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 
)

Definition at line 100 of file Parallelizer.h.

◆ parg()

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::parg ( const Packet a)
inline

Definition at line 551 of file GenericPacketMath.h.

◆ parithmetic_shift_right() [1/22]

template<int N>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::parithmetic_shift_right ( PacketXi  a)

Definition at line 204 of file SVE/PacketMath.h.

◆ parithmetic_shift_right() [2/22]

template<int N>
EIGEN_STRONG_INLINE Packet8i Eigen::internal::parithmetic_shift_right ( Packet8i  a)

Definition at line 547 of file AVX/PacketMath.h.

◆ parithmetic_shift_right() [3/22]

template<int N>
EIGEN_DEVICE_FUNC int Eigen::internal::parithmetic_shift_right ( const int a)
inline

Definition at line 556 of file GenericPacketMath.h.

◆ parithmetic_shift_right() [4/22]

template<int N>
EIGEN_DEVICE_FUNC long int Eigen::internal::parithmetic_shift_right ( const long int a)
inline

Definition at line 558 of file GenericPacketMath.h.

◆ parithmetic_shift_right() [5/22]

template<int N>
EIGEN_STRONG_INLINE Packet16i Eigen::internal::parithmetic_shift_right ( Packet16i  a)

Definition at line 666 of file AVX512/PacketMath.h.

◆ parithmetic_shift_right() [6/22]

template<int N>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::parithmetic_shift_right ( const Packet4i a)

Definition at line 1187 of file AltiVec/PacketMath.h.

◆ parithmetic_shift_right() [7/22]

template<int N>
EIGEN_STRONG_INLINE Packet4c Eigen::internal::parithmetic_shift_right ( Packet4c a)

Definition at line 1600 of file NEON/PacketMath.h.

◆ parithmetic_shift_right() [8/22]

template<int N>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::parithmetic_shift_right ( Packet8c  a)

Definition at line 1602 of file NEON/PacketMath.h.

◆ parithmetic_shift_right() [9/22]

template<int N>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::parithmetic_shift_right ( Packet16c  a)

Definition at line 1603 of file NEON/PacketMath.h.

◆ parithmetic_shift_right() [10/22]

template<int N>
EIGEN_STRONG_INLINE Packet4uc Eigen::internal::parithmetic_shift_right ( Packet4uc a)

Definition at line 1604 of file NEON/PacketMath.h.

◆ parithmetic_shift_right() [11/22]

template<int N>
EIGEN_STRONG_INLINE Packet8uc Eigen::internal::parithmetic_shift_right ( Packet8uc  a)

Definition at line 1606 of file NEON/PacketMath.h.

◆ parithmetic_shift_right() [12/22]

template<int N>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::parithmetic_shift_right ( Packet16uc  a)

Definition at line 1607 of file NEON/PacketMath.h.

◆ parithmetic_shift_right() [13/22]

template<int N>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::parithmetic_shift_right ( Packet4s  a)

Definition at line 1608 of file NEON/PacketMath.h.

◆ parithmetic_shift_right() [14/22]

template<int N>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::parithmetic_shift_right ( Packet8s  a)

Definition at line 1609 of file NEON/PacketMath.h.

◆ parithmetic_shift_right() [15/22]

template<int N>
EIGEN_STRONG_INLINE Packet4us Eigen::internal::parithmetic_shift_right ( Packet4us  a)

Definition at line 1610 of file NEON/PacketMath.h.

◆ parithmetic_shift_right() [16/22]

template<int N>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::parithmetic_shift_right ( Packet8us  a)

Definition at line 1611 of file NEON/PacketMath.h.

◆ parithmetic_shift_right() [17/22]

template<int N>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::parithmetic_shift_right ( Packet2i  a)

Definition at line 1612 of file NEON/PacketMath.h.

◆ parithmetic_shift_right() [18/22]

template<int N>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::parithmetic_shift_right ( Packet4i  a)

Definition at line 1613 of file NEON/PacketMath.h.

◆ parithmetic_shift_right() [19/22]

template<int N>
EIGEN_STRONG_INLINE Packet2ui Eigen::internal::parithmetic_shift_right ( Packet2ui  a)

Definition at line 1614 of file NEON/PacketMath.h.

◆ parithmetic_shift_right() [20/22]

template<int N>
EIGEN_STRONG_INLINE Packet4ui Eigen::internal::parithmetic_shift_right ( Packet4ui  a)

Definition at line 1615 of file NEON/PacketMath.h.

◆ parithmetic_shift_right() [21/22]

template<int N>
EIGEN_STRONG_INLINE Packet2l Eigen::internal::parithmetic_shift_right ( Packet2l  a)

Definition at line 1616 of file NEON/PacketMath.h.

◆ parithmetic_shift_right() [22/22]

template<int N>
EIGEN_STRONG_INLINE Packet2ul Eigen::internal::parithmetic_shift_right ( Packet2ul  a)

Definition at line 1617 of file NEON/PacketMath.h.

◆ partial_lu_inplace()

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

Definition at line 505 of file PartialPivLU.h.

◆ pasin() [1/2]

template<typename Packet >
static Packet Eigen::internal::pasin ( Packet  a)
inlinestatic

◆ pasin() [2/2]

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pasin ( const Packet a)

Definition at line 764 of file GenericPacketMath.h.

◆ patan()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::patan ( const Packet a)

Definition at line 772 of file GenericPacketMath.h.

◆ pbessel_i0()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_i0 ( const Packet x)

Definition at line 21 of file BesselFunctionsPacketMath.h.

◆ pbessel_i0e()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_i0e ( const Packet x)

Definition at line 29 of file BesselFunctionsPacketMath.h.

◆ pbessel_i1()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_i1 ( const Packet x)

Definition at line 37 of file BesselFunctionsPacketMath.h.

◆ pbessel_i1e()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_i1e ( const Packet x)

Definition at line 45 of file BesselFunctionsPacketMath.h.

◆ pbessel_j0()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_j0 ( const Packet x)

Definition at line 53 of file BesselFunctionsPacketMath.h.

◆ pbessel_j1()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_j1 ( const Packet x)

Definition at line 61 of file BesselFunctionsPacketMath.h.

◆ pbessel_k0()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_k0 ( const Packet x)

Definition at line 85 of file BesselFunctionsPacketMath.h.

◆ pbessel_k0e()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_k0e ( const Packet x)

Definition at line 93 of file BesselFunctionsPacketMath.h.

◆ pbessel_k1()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_k1 ( const Packet x)

Definition at line 101 of file BesselFunctionsPacketMath.h.

◆ pbessel_k1e()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_k1e ( const Packet x)

Definition at line 109 of file BesselFunctionsPacketMath.h.

◆ pbessel_y0()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_y0 ( const Packet x)

Definition at line 69 of file BesselFunctionsPacketMath.h.

◆ pbessel_y1()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_y1 ( const Packet x)

Definition at line 77 of file BesselFunctionsPacketMath.h.

◆ pbetainc()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::pbetainc ( const Packet a,
const Packet b,
const Packet x 
)

Definition at line 73 of file SpecialFunctionsPacketMath.h.

◆ pblend() [1/14]

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

Definition at line 333 of file MSA/Complex.h.

◆ pblend() [2/14]

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

Definition at line 921 of file AVX/PacketMath.h.

◆ pblend() [3/14]

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

Definition at line 927 of file AVX/PacketMath.h.

◆ pblend() [4/14]

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

Definition at line 1032 of file GenericPacketMath.h.

◆ pblend() [5/14]

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

Definition at line 1222 of file MSA/PacketMath.h.

◆ pblend() [6/14]

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

Definition at line 1356 of file AVX512/PacketMath.h.

◆ pblend() [7/14]

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

Definition at line 1363 of file AVX512/PacketMath.h.

◆ pblend() [8/14]

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

Definition at line 2107 of file AltiVec/PacketMath.h.

◆ pblend() [9/14]

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

Definition at line 2111 of file AltiVec/PacketMath.h.

◆ pblend() [10/14]

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

Definition at line 2115 of file AltiVec/PacketMath.h.

◆ pblend() [11/14]

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

Definition at line 2123 of file AltiVec/PacketMath.h.

◆ pblend() [12/14]

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

Definition at line 2130 of file AltiVec/PacketMath.h.

◆ pblend() [13/14]

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

Definition at line 2134 of file AltiVec/PacketMath.h.

◆ pblend() [14/14]

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

Definition at line 2144 of file AltiVec/PacketMath.h.

◆ pblend4()

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

Definition at line 2101 of file AltiVec/PacketMath.h.

◆ pbroadcast2()

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

Definition at line 670 of file GenericPacketMath.h.

◆ 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

Definition at line 653 of file GenericPacketMath.h.

◆ pbroadcast4< Packet2d >()

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

Definition at line 960 of file SSE/PacketMath.h.

◆ pbroadcast4< Packet4f >()

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

Definition at line 591 of file AltiVec/PacketMath.h.

◆ pbroadcast4< Packet4i >()

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

Definition at line 597 of file AltiVec/PacketMath.h.

◆ pbroadcast4_common()

template<typename Packet >
EIGEN_STRONG_INLINE void Eigen::internal::pbroadcast4_common ( const __UNPACK_TYPE__(Packet) *  a,
Packet a0,
Packet a1,
Packet a2,
Packet a3 
)

Definition at line 580 of file AltiVec/PacketMath.h.

◆ pbroadcast4_old()

template<typename Packet >
EIGEN_ALWAYS_INLINE void Eigen::internal::pbroadcast4_old ( const __UNPACK_TYPE__(Packet) *  a,
Packet a0,
Packet a1,
Packet a2,
Packet a3 
)

Definition at line 1285 of file MatrixProduct.h.

◆ pbroadcast4_old< Packet2d >()

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

Definition at line 1291 of file MatrixProduct.h.

◆ pcast() [1/4]

template<typename SrcPacket , typename TgtPacket >
EIGEN_DEVICE_FUNC TgtPacket Eigen::internal::pcast ( const SrcPacket &  a)
inline

Definition at line 188 of file GenericPacketMath.h.

◆ pcast() [2/4]

template<typename SrcPacket , typename TgtPacket >
EIGEN_DEVICE_FUNC TgtPacket Eigen::internal::pcast ( const SrcPacket &  a,
const SrcPacket &   
)
inline

Definition at line 193 of file GenericPacketMath.h.

◆ pcast() [3/4]

template<typename SrcPacket , typename TgtPacket >
EIGEN_DEVICE_FUNC TgtPacket Eigen::internal::pcast ( const SrcPacket &  a,
const SrcPacket &  ,
const SrcPacket &  ,
const SrcPacket &   
)
inline

Definition at line 198 of file GenericPacketMath.h.

◆ pcast() [4/4]

template<typename SrcPacket , typename TgtPacket >
EIGEN_DEVICE_FUNC TgtPacket Eigen::internal::pcast ( const SrcPacket &  a,
const SrcPacket &  ,
const SrcPacket &  ,
const SrcPacket &  ,
const SrcPacket &  ,
const SrcPacket &  ,
const SrcPacket &  ,
const SrcPacket &   
)
inline

Definition at line 203 of file GenericPacketMath.h.

◆ pcast< float, Packet1cf >()

template<>
EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pcast< float, Packet1cf > ( const float &  a)

Definition at line 104 of file NEON/Complex.h.

◆ pcast< Packet16bf, Packet16f >()

Definition at line 68 of file AVX512/TypeCasting.h.

◆ pcast< Packet16c, Packet16c >()

Definition at line 255 of file NEON/TypeCasting.h.

◆ pcast< Packet16c, Packet16uc >()

Definition at line 272 of file NEON/TypeCasting.h.

◆ pcast< Packet16c, Packet2l >()

Definition at line 180 of file NEON/TypeCasting.h.

◆ pcast< Packet16c, Packet2ul >()

Definition at line 190 of file NEON/TypeCasting.h.

◆ pcast< Packet16c, Packet4f >()

Definition at line 165 of file NEON/TypeCasting.h.

◆ pcast< Packet16c, Packet4i >()

Definition at line 199 of file NEON/TypeCasting.h.

◆ pcast< Packet16c, Packet4ui >()

Definition at line 214 of file NEON/TypeCasting.h.

◆ pcast< Packet16c, Packet8s >()

Definition at line 227 of file NEON/TypeCasting.h.

◆ pcast< Packet16c, Packet8us >()

Definition at line 242 of file NEON/TypeCasting.h.

◆ pcast< Packet16f, Packet16bf >()

Definition at line 81 of file AVX512/TypeCasting.h.

◆ pcast< Packet16f, Packet16h >()

Definition at line 55 of file AVX512/TypeCasting.h.

◆ pcast< Packet16f, Packet16i >()

Definition at line 17 of file AVX512/TypeCasting.h.

◆ pcast< Packet16h, Packet16f >()

Definition at line 42 of file AVX512/TypeCasting.h.

◆ pcast< Packet16i, Packet16f >()

Definition at line 21 of file AVX512/TypeCasting.h.

◆ pcast< Packet16uc, Packet16c >()

Definition at line 399 of file NEON/TypeCasting.h.

◆ pcast< Packet16uc, Packet16uc >()

Definition at line 382 of file NEON/TypeCasting.h.

◆ pcast< Packet16uc, Packet2l >()

Definition at line 317 of file NEON/TypeCasting.h.

◆ pcast< Packet16uc, Packet2ul >()

Definition at line 307 of file NEON/TypeCasting.h.

◆ pcast< Packet16uc, Packet4f >()

Definition at line 292 of file NEON/TypeCasting.h.

◆ pcast< Packet16uc, Packet4i >()

Definition at line 341 of file NEON/TypeCasting.h.

◆ pcast< Packet16uc, Packet4ui >()

Definition at line 326 of file NEON/TypeCasting.h.

◆ pcast< Packet16uc, Packet8s >()

Definition at line 369 of file NEON/TypeCasting.h.

◆ pcast< Packet16uc, Packet8us >()

Definition at line 354 of file NEON/TypeCasting.h.

◆ pcast< Packet2d, Packet4f >()

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

Definition at line 63 of file SSE/TypeCasting.h.

◆ pcast< Packet2f, Packet2cf >()

Definition at line 106 of file NEON/Complex.h.

◆ pcast< Packet2f, Packet2f >()

Definition at line 30 of file NEON/TypeCasting.h.

◆ pcast< Packet2f, Packet2i >()

Definition at line 76 of file NEON/TypeCasting.h.

◆ pcast< Packet2f, Packet2ui >()

Definition at line 89 of file NEON/TypeCasting.h.

◆ pcast< Packet2f, Packet4s >()

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

Definition at line 102 of file NEON/TypeCasting.h.

◆ pcast< Packet2f, Packet4us >()

Definition at line 115 of file NEON/TypeCasting.h.

◆ pcast< Packet2f, Packet8c >()

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

Definition at line 131 of file NEON/TypeCasting.h.

◆ pcast< Packet2f, Packet8uc >()

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

Definition at line 150 of file NEON/TypeCasting.h.

◆ pcast< Packet2i, Packet2f >()

Definition at line 657 of file NEON/TypeCasting.h.

◆ pcast< Packet2i, Packet2i >()

Definition at line 689 of file NEON/TypeCasting.h.

◆ pcast< Packet2i, Packet2ui >()

Definition at line 702 of file NEON/TypeCasting.h.

◆ pcast< Packet2i, Packet4s >()

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

Definition at line 715 of file NEON/TypeCasting.h.

◆ pcast< Packet2i, Packet4us >()

Definition at line 728 of file NEON/TypeCasting.h.

◆ pcast< Packet2i, Packet8c >()

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

Definition at line 744 of file NEON/TypeCasting.h.

◆ pcast< Packet2i, Packet8uc >()

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

Definition at line 763 of file NEON/TypeCasting.h.

◆ pcast< Packet2l, Packet16c >()

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcast< Packet2l, Packet16c > ( const Packet2l a,
const Packet2l b,
const Packet2l c,
const Packet2l d,
const Packet2l e,
const Packet2l f,
const Packet2l g,
const Packet2l h 
)

Definition at line 968 of file NEON/TypeCasting.h.

◆ pcast< Packet2l, Packet16uc >()

template<>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcast< Packet2l, Packet16uc > ( const Packet2l a,
const Packet2l b,
const Packet2l c,
const Packet2l d,
const Packet2l e,
const Packet2l f,
const Packet2l g,
const Packet2l h 
)

Definition at line 981 of file NEON/TypeCasting.h.

◆ pcast< Packet2l, Packet2l >()

Definition at line 908 of file NEON/TypeCasting.h.

◆ pcast< Packet2l, Packet2ul >()

Definition at line 917 of file NEON/TypeCasting.h.

◆ pcast< Packet2l, Packet4f >()

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

Definition at line 899 of file NEON/TypeCasting.h.

◆ pcast< Packet2l, Packet4i >()

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

Definition at line 926 of file NEON/TypeCasting.h.

◆ pcast< Packet2l, Packet4ui >()

Definition at line 935 of file NEON/TypeCasting.h.

◆ pcast< Packet2l, Packet8s >()

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

Definition at line 944 of file NEON/TypeCasting.h.

◆ pcast< Packet2l, Packet8us >()

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

Definition at line 956 of file NEON/TypeCasting.h.

◆ pcast< Packet2ui, Packet2f >()

Definition at line 782 of file NEON/TypeCasting.h.

◆ pcast< Packet2ui, Packet2i >()

Definition at line 827 of file NEON/TypeCasting.h.

◆ pcast< Packet2ui, Packet2ui >()

Definition at line 814 of file NEON/TypeCasting.h.

◆ pcast< Packet2ui, Packet4s >()

Definition at line 853 of file NEON/TypeCasting.h.

◆ pcast< Packet2ui, Packet4us >()

Definition at line 840 of file NEON/TypeCasting.h.

◆ pcast< Packet2ui, Packet8c >()

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

Definition at line 886 of file NEON/TypeCasting.h.

◆ pcast< Packet2ui, Packet8uc >()

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

Definition at line 869 of file NEON/TypeCasting.h.

◆ pcast< Packet2ul, Packet16c >()

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcast< Packet2ul, Packet16c > ( const Packet2ul a,
const Packet2ul b,
const Packet2ul c,
const Packet2ul d,
const Packet2ul e,
const Packet2ul f,
const Packet2ul g,
const Packet2ul h 
)

Definition at line 1077 of file NEON/TypeCasting.h.

◆ pcast< Packet2ul, Packet16uc >()

template<>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcast< Packet2ul, Packet16uc > ( const Packet2ul a,
const Packet2ul b,
const Packet2ul c,
const Packet2ul d,
const Packet2ul e,
const Packet2ul f,
const Packet2ul g,
const Packet2ul h 
)

Definition at line 1064 of file NEON/TypeCasting.h.

◆ pcast< Packet2ul, Packet2l >()

Definition at line 1015 of file NEON/TypeCasting.h.

◆ pcast< Packet2ul, Packet2ul >()

Definition at line 1006 of file NEON/TypeCasting.h.

◆ pcast< Packet2ul, Packet4f >()

Definition at line 997 of file NEON/TypeCasting.h.

◆ pcast< Packet2ul, Packet4i >()

Definition at line 1033 of file NEON/TypeCasting.h.

◆ pcast< Packet2ul, Packet4ui >()

Definition at line 1024 of file NEON/TypeCasting.h.

◆ pcast< Packet2ul, Packet8s >()

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

Definition at line 1054 of file NEON/TypeCasting.h.

◆ pcast< Packet2ul, Packet8us >()

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

Definition at line 1042 of file NEON/TypeCasting.h.

◆ pcast< Packet4c, Packet4c >()

Definition at line 263 of file NEON/TypeCasting.h.

◆ pcast< Packet4c, Packet4uc >()

Definition at line 280 of file NEON/TypeCasting.h.

◆ pcast< Packet4f, Packet16c >()

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

Definition at line 124 of file NEON/TypeCasting.h.

◆ pcast< Packet4f, Packet16uc >()

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

Definition at line 143 of file NEON/TypeCasting.h.

◆ pcast< Packet4f, Packet2d >()

Definition at line 67 of file SSE/TypeCasting.h.

◆ pcast< Packet4f, Packet2l >()

Definition at line 56 of file NEON/TypeCasting.h.

◆ pcast< Packet4f, Packet2ul >()

Definition at line 61 of file NEON/TypeCasting.h.

◆ pcast< Packet4f, Packet4f >()

Definition at line 26 of file NEON/TypeCasting.h.

◆ pcast< Packet4f, Packet4i >()

Definition at line 2190 of file AltiVec/PacketMath.h.

◆ pcast< Packet4f, Packet4ui >()

Definition at line 2194 of file AltiVec/PacketMath.h.

◆ pcast< Packet4f, Packet8s >()

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

Definition at line 98 of file NEON/TypeCasting.h.

◆ pcast< Packet4f, Packet8us >()

Definition at line 111 of file NEON/TypeCasting.h.

◆ pcast< Packet4i, Packet16c >()

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

Definition at line 737 of file NEON/TypeCasting.h.

◆ pcast< Packet4i, Packet16uc >()

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

Definition at line 756 of file NEON/TypeCasting.h.

◆ pcast< Packet4i, Packet2l >()

Definition at line 666 of file NEON/TypeCasting.h.

◆ pcast< Packet4i, Packet2ul >()

Definition at line 676 of file NEON/TypeCasting.h.

◆ pcast< Packet4i, Packet4f >()

Definition at line 2198 of file AltiVec/PacketMath.h.

◆ pcast< Packet4i, Packet4i >()

Definition at line 685 of file NEON/TypeCasting.h.

◆ pcast< Packet4i, Packet4ui >()

Definition at line 698 of file NEON/TypeCasting.h.

◆ pcast< Packet4i, Packet8s >()

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

Definition at line 711 of file NEON/TypeCasting.h.

◆ pcast< Packet4i, Packet8us >()

Definition at line 724 of file NEON/TypeCasting.h.

◆ pcast< Packet4s, Packet2f >()

Definition at line 424 of file NEON/TypeCasting.h.

◆ pcast< Packet4s, Packet2i >()

Definition at line 458 of file NEON/TypeCasting.h.

◆ pcast< Packet4s, Packet2ui >()

Definition at line 472 of file NEON/TypeCasting.h.

◆ pcast< Packet4s, Packet4s >()

Definition at line 485 of file NEON/TypeCasting.h.

◆ pcast< Packet4s, Packet4us >()

Definition at line 498 of file NEON/TypeCasting.h.

◆ pcast< Packet4s, Packet8c >()

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

Definition at line 511 of file NEON/TypeCasting.h.

◆ pcast< Packet4s, Packet8uc >()

Definition at line 524 of file NEON/TypeCasting.h.

◆ pcast< Packet4uc, Packet4c >()

Definition at line 407 of file NEON/TypeCasting.h.

◆ pcast< Packet4uc, Packet4uc >()

Definition at line 390 of file NEON/TypeCasting.h.

◆ pcast< Packet4ui, Packet16c >()

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

Definition at line 881 of file NEON/TypeCasting.h.

◆ pcast< Packet4ui, Packet16uc >()

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

Definition at line 862 of file NEON/TypeCasting.h.

◆ pcast< Packet4ui, Packet2l >()

Definition at line 801 of file NEON/TypeCasting.h.

◆ pcast< Packet4ui, Packet2ul >()

Definition at line 791 of file NEON/TypeCasting.h.

◆ pcast< Packet4ui, Packet4f >()

Definition at line 2202 of file AltiVec/PacketMath.h.

◆ pcast< Packet4ui, Packet4i >()

Definition at line 823 of file NEON/TypeCasting.h.

◆ pcast< Packet4ui, Packet4ui >()

Definition at line 810 of file NEON/TypeCasting.h.

◆ pcast< Packet4ui, Packet8s >()

Definition at line 849 of file NEON/TypeCasting.h.

◆ pcast< Packet4ui, Packet8us >()

Definition at line 836 of file NEON/TypeCasting.h.

◆ pcast< Packet4us, Packet2f >()

Definition at line 541 of file NEON/TypeCasting.h.

◆ pcast< Packet4us, Packet2i >()

Definition at line 589 of file NEON/TypeCasting.h.

◆ pcast< Packet4us, Packet2ui >()

Definition at line 575 of file NEON/TypeCasting.h.

◆ pcast< Packet4us, Packet4s >()

Definition at line 615 of file NEON/TypeCasting.h.

◆ pcast< Packet4us, Packet4us >()

Definition at line 602 of file NEON/TypeCasting.h.

◆ pcast< Packet4us, Packet8c >()

Definition at line 641 of file NEON/TypeCasting.h.

◆ pcast< Packet4us, Packet8uc >()

Definition at line 628 of file NEON/TypeCasting.h.

◆ pcast< Packet8bf, Packet8f >()

Definition at line 99 of file AVX/TypeCasting.h.

◆ pcast< Packet8bf, Packet8us >()

Definition at line 2206 of file AltiVec/PacketMath.h.

◆ pcast< Packet8c, Packet2f >()

Definition at line 170 of file NEON/TypeCasting.h.

◆ pcast< Packet8c, Packet2i >()

Definition at line 204 of file NEON/TypeCasting.h.

◆ pcast< Packet8c, Packet2ui >()

Definition at line 218 of file NEON/TypeCasting.h.

◆ pcast< Packet8c, Packet4s >()

Definition at line 232 of file NEON/TypeCasting.h.

◆ pcast< Packet8c, Packet4us >()

Definition at line 246 of file NEON/TypeCasting.h.

◆ pcast< Packet8c, Packet8c >()

Definition at line 259 of file NEON/TypeCasting.h.

◆ pcast< Packet8c, Packet8uc >()

Definition at line 276 of file NEON/TypeCasting.h.

◆ pcast< Packet8f, Packet8bf >()

Definition at line 107 of file AVX/TypeCasting.h.

◆ pcast< Packet8f, Packet8h >()

Definition at line 103 of file AVX/TypeCasting.h.

◆ pcast< Packet8f, Packet8i >()

Definition at line 79 of file AVX/TypeCasting.h.

◆ pcast< Packet8h, Packet8f >()

Definition at line 95 of file AVX/TypeCasting.h.

◆ pcast< Packet8i, Packet8f >()

Definition at line 83 of file AVX/TypeCasting.h.

◆ pcast< Packet8s, Packet16c >()

Definition at line 507 of file NEON/TypeCasting.h.

◆ pcast< Packet8s, Packet16uc >()

Definition at line 520 of file NEON/TypeCasting.h.

◆ pcast< Packet8s, Packet2l >()

Definition at line 434 of file NEON/TypeCasting.h.

◆ pcast< Packet8s, Packet2ul >()

Definition at line 444 of file NEON/TypeCasting.h.

◆ pcast< Packet8s, Packet4f >()

Definition at line 419 of file NEON/TypeCasting.h.

◆ pcast< Packet8s, Packet4i >()

Definition at line 453 of file NEON/TypeCasting.h.

◆ pcast< Packet8s, Packet4ui >()

Definition at line 468 of file NEON/TypeCasting.h.

◆ pcast< Packet8s, Packet8s >()

Definition at line 481 of file NEON/TypeCasting.h.

◆ pcast< Packet8s, Packet8us >()

Definition at line 494 of file NEON/TypeCasting.h.

◆ pcast< Packet8uc, Packet2f >()

Definition at line 297 of file NEON/TypeCasting.h.

◆ pcast< Packet8uc, Packet2i >()

Definition at line 345 of file NEON/TypeCasting.h.

◆ pcast< Packet8uc, Packet2ui >()

Definition at line 331 of file NEON/TypeCasting.h.

◆ pcast< Packet8uc, Packet4s >()

Definition at line 373 of file NEON/TypeCasting.h.

◆ pcast< Packet8uc, Packet4us >()

Definition at line 359 of file NEON/TypeCasting.h.

◆ pcast< Packet8uc, Packet8c >()

Definition at line 403 of file NEON/TypeCasting.h.

◆ pcast< Packet8uc, Packet8uc >()

Definition at line 386 of file NEON/TypeCasting.h.

◆ pcast< Packet8us, Packet16c >()

Definition at line 637 of file NEON/TypeCasting.h.

◆ pcast< Packet8us, Packet16uc >()

Definition at line 624 of file NEON/TypeCasting.h.

◆ pcast< Packet8us, Packet2l >()

Definition at line 561 of file NEON/TypeCasting.h.

◆ pcast< Packet8us, Packet2ul >()

Definition at line 551 of file NEON/TypeCasting.h.

◆ pcast< Packet8us, Packet4f >()

Definition at line 536 of file NEON/TypeCasting.h.

◆ pcast< Packet8us, Packet4i >()

Definition at line 585 of file NEON/TypeCasting.h.

◆ pcast< Packet8us, Packet4ui >()

Definition at line 570 of file NEON/TypeCasting.h.

◆ pcast< Packet8us, Packet8bf >()

Definition at line 2232 of file AltiVec/PacketMath.h.

◆ pcast< Packet8us, Packet8s >()

Definition at line 611 of file NEON/TypeCasting.h.

◆ pcast< Packet8us, Packet8us >()

Definition at line 598 of file NEON/TypeCasting.h.

◆ pcast< PacketXf, PacketXi >()

template<>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::pcast< PacketXf, PacketXi > ( const PacketXf &  a)

Definition at line 32 of file SVE/TypeCasting.h.

◆ pcast< PacketXi, PacketXf >()

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::pcast< PacketXi, PacketXf > ( const PacketXi &  a)

Definition at line 27 of file SVE/TypeCasting.h.

◆ pceil()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pceil ( const Packet a)

Definition at line 839 of file GenericPacketMath.h.

◆ pceil< Packet16bf >()

Definition at line 2023 of file AVX512/PacketMath.h.

◆ pceil< Packet16f >()

Definition at line 529 of file AVX512/PacketMath.h.

◆ pceil< Packet16h >()

Definition at line 1539 of file AVX512/PacketMath.h.

◆ pceil< Packet2d >()

Definition at line 1182 of file MSA/PacketMath.h.

◆ pceil< Packet2f >()

Definition at line 3173 of file NEON/PacketMath.h.

◆ pceil< Packet4bf >()

Definition at line 3531 of file NEON/PacketMath.h.

◆ pceil< Packet4d >()

Definition at line 453 of file AVX/PacketMath.h.

◆ pceil< Packet4f >()

Definition at line 938 of file AltiVec/PacketMath.h.

◆ pceil< Packet8bf >()

Definition at line 1387 of file AltiVec/PacketMath.h.

◆ pceil< Packet8d >()

Definition at line 530 of file AVX512/PacketMath.h.

◆ pceil< Packet8f >()

Definition at line 452 of file AVX/PacketMath.h.

◆ pceil< Packet8h >()

Definition at line 1069 of file AVX/PacketMath.h.

◆ pcmp_eq() [1/26]

template<>
EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pcmp_eq ( const Packet4cf a,
const Packet4cf b 
)

Definition at line 85 of file AVX/Complex.h.

◆ pcmp_eq() [2/26]

template<>
EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pcmp_eq ( const Packet8cf a,
const Packet8cf b 
)

Definition at line 89 of file AVX512/Complex.h.

◆ pcmp_eq() [3/26]

template<>
EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pcmp_eq ( const Packet1cf a,
const Packet1cf b 
)

Definition at line 180 of file NEON/Complex.h.

◆ pcmp_eq() [4/26]

template<>
EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pcmp_eq ( const Packet2cf a,
const Packet2cf b 
)

Definition at line 231 of file AltiVec/Complex.h.

◆ pcmp_eq() [5/26]

template<>
EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pcmp_eq ( const Packet4cd a,
const Packet4cd b 
)

Definition at line 244 of file AVX512/Complex.h.

◆ pcmp_eq() [6/26]

template<>
EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pcmp_eq ( const Packet2cd a,
const Packet2cd b 
)

Definition at line 253 of file AVX/Complex.h.

◆ pcmp_eq() [7/26]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pcmp_eq ( const Packet a,
const Packet b 
)
inline

Definition at line 310 of file GenericPacketMath.h.

◆ pcmp_eq() [8/26]

template<>
EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pcmp_eq ( const Packet1cd a,
const Packet1cd b 
)

Definition at line 329 of file SSE/Complex.h.

◆ pcmp_eq() [9/26]

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pcmp_eq ( const Packet8f a,
const Packet8f b 
)

Definition at line 348 of file AVX/PacketMath.h.

◆ pcmp_eq() [10/26]

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pcmp_eq ( const Packet4d a,
const Packet4d b 
)

Definition at line 353 of file AVX/PacketMath.h.

◆ pcmp_eq() [11/26]

template<>
EIGEN_STRONG_INLINE Packet8i Eigen::internal::pcmp_eq ( const Packet8i a,
const Packet8i b 
)

Definition at line 356 of file AVX/PacketMath.h.

◆ pcmp_eq() [12/26]

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pcmp_eq ( const Packet2d a,
const Packet2d b 
)

Definition at line 439 of file SSE/PacketMath.h.

◆ pcmp_eq() [13/26]

template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::pcmp_eq ( const Packet16b a,
const Packet16b b 
)

Definition at line 443 of file SSE/PacketMath.h.

◆ pcmp_eq() [14/26]

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pcmp_eq ( const Packet16f a,
const Packet16f b 
)

Definition at line 472 of file AVX512/PacketMath.h.

◆ pcmp_eq() [15/26]

template<>
EIGEN_STRONG_INLINE Packet16i Eigen::internal::pcmp_eq ( const Packet16i a,
const Packet16i b 
)

Definition at line 495 of file AVX512/PacketMath.h.

◆ pcmp_eq() [16/26]

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pcmp_eq ( const Packet8d a,
const Packet8d b 
)

Definition at line 502 of file AVX512/PacketMath.h.

◆ pcmp_eq() [17/26]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_eq ( const Packet4f a,
const Packet4f b 
)

Definition at line 869 of file AltiVec/PacketMath.h.

◆ pcmp_eq() [18/26]

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_eq ( const Packet4i a,
const Packet4i b 
)

Definition at line 877 of file AltiVec/PacketMath.h.

◆ pcmp_eq() [19/26]

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcmp_eq ( const Packet8s a,
const Packet8s b 
)

Definition at line 880 of file AltiVec/PacketMath.h.

◆ pcmp_eq() [20/26]

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcmp_eq ( const Packet8us a,
const Packet8us b 
)

Definition at line 883 of file AltiVec/PacketMath.h.

◆ pcmp_eq() [21/26]

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcmp_eq ( const Packet16c a,
const Packet16c b 
)

Definition at line 886 of file AltiVec/PacketMath.h.

◆ pcmp_eq() [22/26]

template<>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcmp_eq ( const Packet16uc a,
const Packet16uc b 
)

Definition at line 889 of file AltiVec/PacketMath.h.

◆ pcmp_eq() [23/26]

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::pcmp_eq ( const Packet8h a,
const Packet8h b 
)

Definition at line 1077 of file AVX/PacketMath.h.

◆ pcmp_eq() [24/26]

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pcmp_eq ( const Packet8bf a,
const Packet8bf b 
)

Definition at line 1425 of file AltiVec/PacketMath.h.

◆ pcmp_eq() [25/26]

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::pcmp_eq ( const Packet16h a,
const Packet16h b 
)

Definition at line 1547 of file AVX512/PacketMath.h.

◆ pcmp_eq() [26/26]

template<>
EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pcmp_eq ( const Packet16bf a,
const Packet16bf b 
)

Definition at line 2032 of file AVX512/PacketMath.h.

◆ pcmp_eq< Packet16c >()

Definition at line 1410 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet16uc >()

Definition at line 1420 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet2f >()

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::pcmp_eq< Packet2f > ( const Packet2f a,
const Packet2f b 
)

Definition at line 1398 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet2i >()

template<>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::pcmp_eq< Packet2i > ( const Packet2i a,
const Packet2i b 
)

Definition at line 1430 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet2l >()

template<>
EIGEN_STRONG_INLINE Packet2l Eigen::internal::pcmp_eq< Packet2l > ( const Packet2l a,
const Packet2l b 
)

Definition at line 1438 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet2ui >()

Definition at line 1434 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet2ul >()

Definition at line 1448 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet4bf >()

Definition at line 3601 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet4c >()

template<>
EIGEN_STRONG_INLINE Packet4c Eigen::internal::pcmp_eq< Packet4c > ( const Packet4c a,
const Packet4c b 
)

Definition at line 1402 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet4f >() [1/2]

template<>
Packet4f EIGEN_STRONG_INLINE Eigen::internal::pcmp_eq< Packet4f > ( const Packet4f a,
const Packet4f b 
)

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

◆ pcmp_eq< Packet4f >() [2/2]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_eq< Packet4f > ( const Packet4f a,
const Packet4f b 
)

Definition at line 1400 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet4i >()

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_eq< Packet4i > ( const Packet4i a,
const Packet4i b 
)

Definition at line 1432 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet4s >()

template<>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::pcmp_eq< Packet4s > ( const Packet4s a,
const Packet4s b 
)

Definition at line 1422 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet4uc >()

Definition at line 1412 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet4ui >()

Definition at line 1436 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet4us >()

Definition at line 1426 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet8c >()

template<>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::pcmp_eq< Packet8c > ( const Packet8c a,
const Packet8c b 
)

Definition at line 1408 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet8s >()

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcmp_eq< Packet8s > ( const Packet8s a,
const Packet8s b 
)

Definition at line 1424 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet8uc >()

Definition at line 1418 of file NEON/PacketMath.h.

◆ pcmp_eq< Packet8us >()

Definition at line 1428 of file NEON/PacketMath.h.

◆ pcmp_eq< PacketXf >()

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

Definition at line 536 of file SVE/PacketMath.h.

◆ pcmp_eq< PacketXi >()

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

Definition at line 162 of file SVE/PacketMath.h.

◆ pcmp_le() [1/16]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pcmp_le ( const Packet a,
const Packet b 
)
inline

Definition at line 302 of file GenericPacketMath.h.

◆ pcmp_le() [2/16]

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pcmp_le ( const Packet8f a,
const Packet8f b 
)

Definition at line 345 of file AVX/PacketMath.h.

◆ pcmp_le() [3/16]

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pcmp_le ( const Packet4d a,
const Packet4d b 
)

Definition at line 350 of file AVX/PacketMath.h.

◆ pcmp_le() [4/16]

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pcmp_le ( const Packet2d a,
const Packet2d b 
)

Definition at line 436 of file SSE/PacketMath.h.

◆ pcmp_le() [5/16]

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pcmp_le ( const Packet16f a,
const Packet16f b 
)

Definition at line 477 of file AVX512/PacketMath.h.

◆ pcmp_le() [6/16]

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pcmp_le ( const Packet8d a,
const Packet8d b 
)

Definition at line 508 of file AVX512/PacketMath.h.

◆ pcmp_le() [7/16]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_le ( const Packet4f a,
const Packet4f b 
)

Definition at line 867 of file AltiVec/PacketMath.h.

◆ pcmp_le() [8/16]

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_le ( const Packet4i a,
const Packet4i b 
)

Definition at line 875 of file AltiVec/PacketMath.h.

◆ pcmp_le() [9/16]

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcmp_le ( const Packet8s a,
const Packet8s b 
)

Definition at line 878 of file AltiVec/PacketMath.h.

◆ pcmp_le() [10/16]

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcmp_le ( const Packet8us a,
const Packet8us b 
)

Definition at line 881 of file AltiVec/PacketMath.h.

◆ pcmp_le() [11/16]

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcmp_le ( const Packet16c a,
const Packet16c b 
)

Definition at line 884 of file AltiVec/PacketMath.h.

◆ pcmp_le() [12/16]

template<>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcmp_le ( const Packet16uc a,
const Packet16uc b 
)

Definition at line 887 of file AltiVec/PacketMath.h.

◆ pcmp_le() [13/16]

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::pcmp_le ( const Packet8h a,
const Packet8h b 
)

Definition at line 1081 of file AVX/PacketMath.h.

◆ pcmp_le() [14/16]

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pcmp_le ( const Packet8bf a,
const Packet8bf b 
)

Definition at line 1422 of file AltiVec/PacketMath.h.

◆ pcmp_le() [15/16]

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::pcmp_le ( const Packet16h a,
const Packet16h b 
)

Definition at line 1553 of file AVX512/PacketMath.h.

◆ pcmp_le() [16/16]

template<>
EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pcmp_le ( const Packet16bf a,
const Packet16bf b 
)

Definition at line 2038 of file AVX512/PacketMath.h.

◆ pcmp_le< Packet16c >()

Definition at line 1288 of file NEON/PacketMath.h.

◆ pcmp_le< Packet16uc >()

Definition at line 1298 of file NEON/PacketMath.h.

◆ pcmp_le< Packet2f >()

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::pcmp_le< Packet2f > ( const Packet2f a,
const Packet2f b 
)

Definition at line 1276 of file NEON/PacketMath.h.

◆ pcmp_le< Packet2i >()

template<>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::pcmp_le< Packet2i > ( const Packet2i a,
const Packet2i b 
)

Definition at line 1308 of file NEON/PacketMath.h.

◆ pcmp_le< Packet2l >()

template<>
EIGEN_STRONG_INLINE Packet2l Eigen::internal::pcmp_le< Packet2l > ( const Packet2l a,
const Packet2l b 
)

Definition at line 1316 of file NEON/PacketMath.h.

◆ pcmp_le< Packet2ui >()

Definition at line 1312 of file NEON/PacketMath.h.

◆ pcmp_le< Packet2ul >()

Definition at line 1326 of file NEON/PacketMath.h.

◆ pcmp_le< Packet4bf >()

Definition at line 3616 of file NEON/PacketMath.h.

◆ pcmp_le< Packet4c >()

template<>
EIGEN_STRONG_INLINE Packet4c Eigen::internal::pcmp_le< Packet4c > ( const Packet4c a,
const Packet4c b 
)

Definition at line 1280 of file NEON/PacketMath.h.

◆ pcmp_le< Packet4f >() [1/2]

template<>
Packet4f EIGEN_STRONG_INLINE Eigen::internal::pcmp_le< Packet4f > ( const Packet4f a,
const Packet4f b 
)

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

◆ pcmp_le< Packet4f >() [2/2]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_le< Packet4f > ( const Packet4f a,
const Packet4f b 
)

Definition at line 1278 of file NEON/PacketMath.h.

◆ pcmp_le< Packet4i >()

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_le< Packet4i > ( const Packet4i a,
const Packet4i b 
)

Definition at line 1310 of file NEON/PacketMath.h.

◆ pcmp_le< Packet4s >()

template<>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::pcmp_le< Packet4s > ( const Packet4s a,
const Packet4s b 
)

Definition at line 1300 of file NEON/PacketMath.h.

◆ pcmp_le< Packet4uc >()

Definition at line 1290 of file NEON/PacketMath.h.

◆ pcmp_le< Packet4ui >()

Definition at line 1314 of file NEON/PacketMath.h.

◆ pcmp_le< Packet4us >()

Definition at line 1304 of file NEON/PacketMath.h.

◆ pcmp_le< Packet8c >()

template<>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::pcmp_le< Packet8c > ( const Packet8c a,
const Packet8c b 
)

Definition at line 1286 of file NEON/PacketMath.h.

◆ pcmp_le< Packet8s >()

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcmp_le< Packet8s > ( const Packet8s a,
const Packet8s b 
)

Definition at line 1302 of file NEON/PacketMath.h.

◆ pcmp_le< Packet8uc >()

Definition at line 1296 of file NEON/PacketMath.h.

◆ pcmp_le< Packet8us >()

Definition at line 1306 of file NEON/PacketMath.h.

◆ pcmp_le< PacketXf >()

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

Definition at line 524 of file SVE/PacketMath.h.

◆ pcmp_le< PacketXi >()

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

Definition at line 150 of file SVE/PacketMath.h.

◆ pcmp_lt() [1/16]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pcmp_lt ( const Packet a,
const Packet b 
)
inline

Definition at line 306 of file GenericPacketMath.h.

◆ pcmp_lt() [2/16]

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pcmp_lt ( const Packet8f a,
const Packet8f b 
)

Definition at line 346 of file AVX/PacketMath.h.

◆ pcmp_lt() [3/16]

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pcmp_lt ( const Packet4d a,
const Packet4d b 
)

Definition at line 351 of file AVX/PacketMath.h.

◆ pcmp_lt() [4/16]

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pcmp_lt ( const Packet2d a,
const Packet2d b 
)

Definition at line 437 of file SSE/PacketMath.h.

◆ pcmp_lt() [5/16]

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pcmp_lt ( const Packet16f a,
const Packet16f b 
)

Definition at line 483 of file AVX512/PacketMath.h.

◆ pcmp_lt() [6/16]

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pcmp_lt ( const Packet8d a,
const Packet8d b 
)

Definition at line 514 of file AVX512/PacketMath.h.

◆ pcmp_lt() [7/16]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_lt ( const Packet4f a,
const Packet4f b 
)

Definition at line 868 of file AltiVec/PacketMath.h.

◆ pcmp_lt() [8/16]

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_lt ( const Packet4i a,
const Packet4i b 
)

Definition at line 876 of file AltiVec/PacketMath.h.

◆ pcmp_lt() [9/16]

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcmp_lt ( const Packet8s a,
const Packet8s b 
)

Definition at line 879 of file AltiVec/PacketMath.h.

◆ pcmp_lt() [10/16]

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::pcmp_lt ( const Packet8us a,
const Packet8us b 
)

Definition at line 882 of file AltiVec/PacketMath.h.

◆ pcmp_lt() [11/16]

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::pcmp_lt ( const Packet16c a,
const Packet16c b 
)

Definition at line 885 of file AltiVec/PacketMath.h.

◆ pcmp_lt() [12/16]

template<>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pcmp_lt ( const Packet16uc a,
const Packet16uc b 
)

Definition at line 888 of file AltiVec/PacketMath.h.

◆ pcmp_lt() [13/16]

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::pcmp_lt ( const Packet8h a,
const Packet8h b 
)

Definition at line 1085 of file AVX/PacketMath.h.

◆ pcmp_lt() [14/16]

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pcmp_lt ( const Packet8bf a,
const Packet8bf b 
)

Definition at line 1416 of file AltiVec/PacketMath.h.

◆ pcmp_lt() [15/16]

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::pcmp_lt ( const Packet16h a,
const Packet16h b 
)

Definition at line 1557 of file AVX512/PacketMath.h.

◆ pcmp_lt() [16/16]

template<>
EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pcmp_lt ( const Packet16bf a,
const Packet16bf b 
)

Definition at line 2044 of file AVX512/PacketMath.h.

◆ pcmp_lt< Packet16c >()

Definition at line 1349 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet16uc >()

Definition at line 1359 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet2f >()

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::pcmp_lt< Packet2f > ( const Packet2f a,
const Packet2f b 
)

Definition at line 1337 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet2i >()

template<>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::pcmp_lt< Packet2i > ( const Packet2i a,
const Packet2i b 
)

Definition at line 1369 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet2l >()

template<>
EIGEN_STRONG_INLINE Packet2l Eigen::internal::pcmp_lt< Packet2l > ( const Packet2l a,
const Packet2l b 
)

Definition at line 1377 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet2ui >()

Definition at line 1373 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet2ul >()

Definition at line 1387 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet4bf >()

Definition at line 3606 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet4c >()

template<>
EIGEN_STRONG_INLINE Packet4c Eigen::internal::pcmp_lt< Packet4c > ( const Packet4c a,
const Packet4c b 
)

Definition at line 1341 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet4f >() [1/2]

template<>
Packet4f EIGEN_STRONG_INLINE Eigen::internal::pcmp_lt< Packet4f > ( const Packet4f a,
const Packet4f b 
)

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

◆ pcmp_lt< Packet4f >() [2/2]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_lt< Packet4f > ( const Packet4f a,
const Packet4f b 
)

Definition at line 1339 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet4i >()

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_lt< Packet4i > ( const Packet4i a,
const Packet4i b 
)

Definition at line 1371 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet4s >()

template<>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::pcmp_lt< Packet4s > ( const Packet4s a,
const Packet4s b 
)

Definition at line 1361 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet4uc >()

Definition at line 1351 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet4ui >()

Definition at line 1375 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet4us >()

Definition at line 1365 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet8c >()

template<>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::pcmp_lt< Packet8c > ( const Packet8c a,
const Packet8c b 
)

Definition at line 1347 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet8s >()

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::pcmp_lt< Packet8s > ( const Packet8s a,
const Packet8s b 
)

Definition at line 1363 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet8uc >()

Definition at line 1357 of file NEON/PacketMath.h.

◆ pcmp_lt< Packet8us >()

Definition at line 1367 of file NEON/PacketMath.h.

◆ pcmp_lt< PacketXf >()

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

Definition at line 530 of file SVE/PacketMath.h.

◆ pcmp_lt< PacketXi >()

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

Definition at line 156 of file SVE/PacketMath.h.

◆ pcmp_lt_or_nan() [1/11]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pcmp_lt_or_nan ( const Packet a,
const Packet b 
)
inline

Definition at line 314 of file GenericPacketMath.h.

◆ pcmp_lt_or_nan() [2/11]

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pcmp_lt_or_nan ( const Packet8f a,
const Packet8f b 
)

Definition at line 347 of file AVX/PacketMath.h.

◆ pcmp_lt_or_nan() [3/11]

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pcmp_lt_or_nan ( const Packet4d a,
const Packet4d b 
)

Definition at line 352 of file AVX/PacketMath.h.

◆ pcmp_lt_or_nan() [4/11]

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pcmp_lt_or_nan ( const Packet2d a,
const Packet2d b 
)

Definition at line 438 of file SSE/PacketMath.h.

◆ pcmp_lt_or_nan() [5/11]

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pcmp_lt_or_nan ( const Packet16f a,
const Packet16f b 
)

Definition at line 489 of file AVX512/PacketMath.h.

◆ pcmp_lt_or_nan() [6/11]

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pcmp_lt_or_nan ( const Packet8d a,
const Packet8d b 
)

Definition at line 520 of file AVX512/PacketMath.h.

◆ pcmp_lt_or_nan() [7/11]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_lt_or_nan ( const Packet4f a,
const Packet4f b 
)

Definition at line 870 of file AltiVec/PacketMath.h.

◆ pcmp_lt_or_nan() [8/11]

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::pcmp_lt_or_nan ( const Packet8h a,
const Packet8h b 
)

Definition at line 1089 of file AVX/PacketMath.h.

◆ pcmp_lt_or_nan() [9/11]

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pcmp_lt_or_nan ( const Packet8bf a,
const Packet8bf b 
)

Definition at line 1419 of file AltiVec/PacketMath.h.

◆ pcmp_lt_or_nan() [10/11]

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::pcmp_lt_or_nan ( const Packet16h a,
const Packet16h b 
)

Definition at line 1561 of file AVX512/PacketMath.h.

◆ pcmp_lt_or_nan() [11/11]

template<>
EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pcmp_lt_or_nan ( const Packet16bf a,
const Packet16bf b 
)

Definition at line 2050 of file AVX512/PacketMath.h.

◆ pcmp_lt_or_nan< Packet2f >()

Definition at line 1459 of file NEON/PacketMath.h.

◆ pcmp_lt_or_nan< Packet4bf >()

Definition at line 3611 of file NEON/PacketMath.h.

◆ pcmp_lt_or_nan< Packet4f >()

Definition at line 1461 of file NEON/PacketMath.h.

◆ pcmp_lt_or_nan< PacketXf >()

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

Definition at line 545 of file SVE/PacketMath.h.

◆ pconj() [1/40]

template<>
EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pconj ( const Packet8cf a)

Definition at line 69 of file AVX512/Complex.h.

◆ pconj() [2/40]

template<>
EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pconj ( const Packet4cf a)

Definition at line 70 of file AVX/Complex.h.

◆ pconj() [3/40]

template<>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::pconj ( const PacketXi &  a)

Definition at line 114 of file SVE/PacketMath.h.

◆ pconj() [4/40]

template<>
EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pconj ( const Packet1cf a)

Definition at line 130 of file NEON/Complex.h.

◆ pconj() [5/40]

template<>
EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pconj ( const Packet2cf a)

Definition at line 167 of file AltiVec/Complex.h.

◆ pconj() [6/40]

template<>
EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pconj ( const Packet4cd a)

Definition at line 220 of file AVX512/Complex.h.

◆ pconj() [7/40]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pconj ( const Packet a)
inline

Definition at line 233 of file GenericPacketMath.h.

◆ pconj() [8/40]

template<>
EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pconj ( const Packet2cd a)

Definition at line 236 of file AVX/Complex.h.

◆ pconj() [9/40]

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pconj ( const Packet8f a)

Definition at line 295 of file AVX/PacketMath.h.

◆ pconj() [10/40]

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pconj ( const Packet4d a)

Definition at line 296 of file AVX/PacketMath.h.

◆ pconj() [11/40]

template<>
EIGEN_STRONG_INLINE Packet8i Eigen::internal::pconj ( const Packet8i a)

Definition at line 297 of file AVX/PacketMath.h.

◆ pconj() [12/40]

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pconj ( const Packet16f a)

Definition at line 300 of file AVX512/PacketMath.h.

◆ pconj() [13/40]

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pconj ( const Packet8d a)

Definition at line 304 of file AVX512/PacketMath.h.

◆ pconj() [14/40]

template<>
EIGEN_STRONG_INLINE Packet16i Eigen::internal::pconj ( const Packet16i a)

Definition at line 308 of file AVX512/PacketMath.h.

◆ pconj() [15/40]

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::pconj ( const PacketXf &  a)

Definition at line 462 of file SVE/PacketMath.h.

◆ pconj() [16/40]

template<>
EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pconj ( const Packet1cd a)

Definition at line 491 of file MSA/Complex.h.

◆ pconj() [17/40]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pconj ( const Packet4f a)

Definition at line 792 of file AltiVec/PacketMath.h.

◆ pconj() [18/40]

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pconj ( const Packet4i a)

Definition at line 793 of file AltiVec/PacketMath.h.

◆ pconj() [19/40]

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::pconj ( const Packet2f a)

Definition at line 894 of file NEON/PacketMath.h.

◆ pconj() [20/40]

template<>
EIGEN_STRONG_INLINE Packet4c Eigen::internal::pconj ( const Packet4c a)

Definition at line 896 of file NEON/PacketMath.h.

◆ pconj() [21/40]

template<>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::pconj ( const Packet8c a)

Definition at line 897 of file NEON/PacketMath.h.

◆ pconj() [22/40]

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::pconj ( const Packet16c a)

Definition at line 898 of file NEON/PacketMath.h.

◆ pconj() [23/40]

template<>
EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pconj ( const Packet4uc a)

Definition at line 899 of file NEON/PacketMath.h.

◆ pconj() [24/40]

template<>
EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pconj ( const Packet8uc a)

Definition at line 900 of file NEON/PacketMath.h.

◆ pconj() [25/40]

template<>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pconj ( const Packet16uc a)

Definition at line 901 of file NEON/PacketMath.h.

◆ pconj() [26/40]

template<>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::pconj ( const Packet4s a)

Definition at line 902 of file NEON/PacketMath.h.

◆ pconj() [27/40]

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::pconj ( const Packet8s a)

Definition at line 903 of file NEON/PacketMath.h.

◆ pconj() [28/40]

template<>
EIGEN_STRONG_INLINE Packet4us Eigen::internal::pconj ( const Packet4us a)

Definition at line 904 of file NEON/PacketMath.h.

◆ pconj() [29/40]

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::pconj ( const Packet8us a)

Definition at line 905 of file NEON/PacketMath.h.

◆ pconj() [30/40]

template<>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::pconj ( const Packet2i a)

Definition at line 906 of file NEON/PacketMath.h.

◆ pconj() [31/40]

template<>
EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pconj ( const Packet2ui a)

Definition at line 908 of file NEON/PacketMath.h.

◆ pconj() [32/40]

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pconj ( const Packet2d a)

Definition at line 909 of file MSA/PacketMath.h.

◆ pconj() [33/40]

template<>
EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pconj ( const Packet4ui a)

Definition at line 909 of file NEON/PacketMath.h.

◆ pconj() [34/40]

template<>
EIGEN_STRONG_INLINE Packet2l Eigen::internal::pconj ( const Packet2l a)

Definition at line 910 of file NEON/PacketMath.h.

◆ pconj() [35/40]

template<>
EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pconj ( const Packet2ul a)

Definition at line 911 of file NEON/PacketMath.h.

◆ pconj() [36/40]

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::pconj ( const Packet8h a)

Definition at line 1093 of file AVX/PacketMath.h.

◆ pconj() [37/40]

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pconj ( const Packet8bf a)

Definition at line 1440 of file AVX/PacketMath.h.

◆ pconj() [38/40]

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::pconj ( const Packet16h a)

Definition at line 1565 of file AVX512/PacketMath.h.

◆ pconj() [39/40]

template<>
EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pconj ( const Packet16bf a)

Definition at line 2062 of file AVX512/PacketMath.h.

◆ pconj() [40/40]

template<>
EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pconj ( const Packet4bf a)

Definition at line 3536 of file NEON/PacketMath.h.

◆ pcos()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pcos ( const Packet a)

Definition at line 756 of file GenericPacketMath.h.

◆ pcos< Packet16f >()

Definition at line 340 of file Eigen/src/Core/arch/AVX512/MathFunctions.h.

◆ pcos< Packet2f >()

Definition at line 30 of file Eigen/src/Core/arch/NEON/MathFunctions.h.

◆ pcos< Packet4f >()

Definition at line 38 of file Eigen/src/Core/arch/AltiVec/MathFunctions.h.

◆ pcos< Packet8bf >()

Definition at line 1378 of file AltiVec/PacketMath.h.

◆ pcos< Packet8f >()

Definition at line 29 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ pcos< PacketXf >()

template<>
EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf Eigen::internal::pcos< PacketXf > ( const PacketXf &  x)

Definition at line 32 of file Eigen/src/Core/arch/SVE/MathFunctions.h.

◆ pcos_float()

template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::pcos_float ( const Packet x)

Definition at line 755 of file GenericPacketMathFunctions.h.

◆ pcosh()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pcosh ( const Packet a)

Definition at line 780 of file GenericPacketMath.h.

◆ pcplxflip() [1/3]

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pcplxflip ( const Packet2cf x)

Definition at line 168 of file SSE/Complex.h.

◆ pcplxflip() [2/3]

EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pcplxflip ( const Packet1cd x)

Definition at line 620 of file MSA/Complex.h.

◆ pcplxflip() [3/3]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pcplxflip ( const Packet a)
inline

Definition at line 741 of file GenericPacketMath.h.

◆ pcplxflip< Packet1cf >()

Definition at line 294 of file NEON/Complex.h.

◆ pcplxflip< Packet2cd >()

Definition at line 330 of file AVX/Complex.h.

◆ pcplxflip< Packet2cf >()

Definition at line 219 of file AltiVec/Complex.h.

◆ pcplxflip< Packet4cd >()

Definition at line 355 of file AVX512/Complex.h.

◆ pcplxflip< Packet4cf >()

Definition at line 181 of file AVX/Complex.h.

◆ pcplxflip< Packet8cf >()

Definition at line 167 of file AVX512/Complex.h.

◆ pdigamma()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pdigamma ( const Packet a)

Definition at line 23 of file SpecialFunctionsPacketMath.h.

◆ pdiv()

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pdiv ( const Packet a,
const Packet b 
)
inline

Definition at line 244 of file GenericPacketMath.h.

◆ pdiv< Packet16bf >()

Definition at line 2091 of file AVX512/PacketMath.h.

◆ pdiv< Packet16c >()

Definition at line 1011 of file NEON/PacketMath.h.

◆ pdiv< Packet16f >()

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pdiv< Packet16f > ( const Packet16f a,
const Packet16f b 
)

Definition at line 329 of file AVX512/PacketMath.h.

◆ pdiv< Packet16h >()

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::pdiv< Packet16h > ( const Packet16h a,
const Packet16h b 
)

Definition at line 1593 of file AVX512/PacketMath.h.

◆ pdiv< Packet16uc >()

Definition at line 1026 of file NEON/PacketMath.h.

◆ pdiv< Packet1cd >()

template<>
EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pdiv< Packet1cd > ( const Packet1cd a,
const Packet1cd b 
)

Definition at line 614 of file MSA/Complex.h.

◆ pdiv< Packet1cf >()

template<>
EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pdiv< Packet1cf > ( const Packet1cf a,
const Packet1cf b 
)

Definition at line 348 of file NEON/Complex.h.

◆ pdiv< Packet2cd >()

template<>
EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pdiv< Packet2cd > ( const Packet2cd a,
const Packet2cd b 
)

Definition at line 322 of file AVX/Complex.h.

◆ pdiv< Packet2cf >()

template<>
EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pdiv< Packet2cf > ( const Packet2cf a,
const Packet2cf b 
)

Definition at line 211 of file AltiVec/Complex.h.

◆ pdiv< Packet2d >()

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pdiv< Packet2d > ( const Packet2d a,
const Packet2d b 
)

Definition at line 923 of file MSA/PacketMath.h.

◆ pdiv< Packet2f >()

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::pdiv< Packet2f > ( const Packet2f a,
const Packet2f b 
)

Definition at line 950 of file NEON/PacketMath.h.

◆ pdiv< Packet2i >()

template<>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::pdiv< Packet2i > ( const Packet2i ,
const Packet2i  
)

Definition at line 1051 of file NEON/PacketMath.h.

◆ pdiv< Packet2l >()

template<>
EIGEN_STRONG_INLINE Packet2l Eigen::internal::pdiv< Packet2l > ( const Packet2l ,
const Packet2l  
)

Definition at line 1071 of file NEON/PacketMath.h.

◆ pdiv< Packet2ui >()

Definition at line 1061 of file NEON/PacketMath.h.

◆ pdiv< Packet2ul >()

Definition at line 1076 of file NEON/PacketMath.h.

◆ pdiv< Packet4bf >()

template<>
EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pdiv< Packet4bf > ( const Packet4bf a,
const Packet4bf b 
)

Definition at line 3550 of file NEON/PacketMath.h.

◆ pdiv< Packet4c >()

template<>
EIGEN_STRONG_INLINE Packet4c Eigen::internal::pdiv< Packet4c > ( const Packet4c ,
const Packet4c  
)

Definition at line 1001 of file NEON/PacketMath.h.

◆ pdiv< Packet4cd >()

template<>
EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pdiv< Packet4cd > ( const Packet4cd a,
const Packet4cd b 
)

Definition at line 347 of file AVX512/Complex.h.

◆ pdiv< Packet4cf >()

template<>
EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pdiv< Packet4cf > ( const Packet4cf a,
const Packet4cf b 
)

Definition at line 172 of file AVX/Complex.h.

◆ pdiv< Packet4d >()

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pdiv< Packet4d > ( const Packet4d a,
const Packet4d b 
)

Definition at line 312 of file AVX/PacketMath.h.

◆ pdiv< Packet4f >()

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pdiv< Packet4f > ( const Packet4f a,
const Packet4f b 
)

Definition at line 803 of file AltiVec/PacketMath.h.

◆ pdiv< Packet4i >()

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pdiv< Packet4i > ( const Packet4i a,
const Packet4i b 
)

Definition at line 821 of file AltiVec/PacketMath.h.

◆ pdiv< Packet4s >()

template<>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::pdiv< Packet4s > ( const Packet4s ,
const Packet4s  
)

Definition at line 1031 of file NEON/PacketMath.h.

◆ pdiv< Packet4uc >()

Definition at line 1016 of file NEON/PacketMath.h.

◆ pdiv< Packet4ui >()

Definition at line 1066 of file NEON/PacketMath.h.

◆ pdiv< Packet4us >()

Definition at line 1041 of file NEON/PacketMath.h.

◆ pdiv< Packet8bf >()

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pdiv< Packet8bf > ( const Packet8bf a,
const Packet8bf b 
)

Definition at line 1332 of file AltiVec/PacketMath.h.

◆ pdiv< Packet8c >()

template<>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::pdiv< Packet8c > ( const Packet8c ,
const Packet8c  
)

Definition at line 1006 of file NEON/PacketMath.h.

◆ pdiv< Packet8cf >()

template<>
EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pdiv< Packet8cf > ( const Packet8cf a,
const Packet8cf b 
)

Definition at line 158 of file AVX512/Complex.h.

◆ pdiv< Packet8d >()

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pdiv< Packet8d > ( const Packet8d a,
const Packet8d b 
)

Definition at line 334 of file AVX512/PacketMath.h.

◆ pdiv< Packet8f >()

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pdiv< Packet8f > ( const Packet8f a,
const Packet8f b 
)

Definition at line 311 of file AVX/PacketMath.h.

◆ pdiv< Packet8h >()

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::pdiv< Packet8h > ( const Packet8h a,
const Packet8h b 
)

Definition at line 1121 of file AVX/PacketMath.h.

◆ pdiv< Packet8i >()

template<>
EIGEN_STRONG_INLINE Packet8i Eigen::internal::pdiv< Packet8i > ( const Packet8i ,
const Packet8i  
)

Definition at line 313 of file AVX/PacketMath.h.

◆ pdiv< Packet8s >()

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::pdiv< Packet8s > ( const Packet8s ,
const Packet8s  
)

Definition at line 1036 of file NEON/PacketMath.h.

◆ pdiv< Packet8uc >()

Definition at line 1021 of file NEON/PacketMath.h.

◆ pdiv< Packet8us >()

Definition at line 1046 of file NEON/PacketMath.h.

◆ pdiv< PacketXf >()

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

Definition at line 474 of file SVE/PacketMath.h.

◆ pdiv< PacketXi >()

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

Definition at line 126 of file SVE/PacketMath.h.

◆ perf()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::perf ( const Packet a)

Definition at line 35 of file SpecialFunctionsPacketMath.h.

◆ perfc()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::perfc ( const Packet a)

Definition at line 39 of file SpecialFunctionsPacketMath.h.

◆ 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 
)

Definition at line 430 of file SparseSelfAdjointView.h.

◆ permute_symm_to_symm() [1/2]

template<int SrcMode, int DstMode, typename MatrixType , int DestOrder>
void Eigen::internal::permute_symm_to_symm ( const MatrixType mat,
SparseMatrix< typename MatrixType::Scalar, DestOrder, typename MatrixType::StorageIndex > &  _dest,
const typename MatrixType::StorageIndex *  perm = 0 
)

◆ permute_symm_to_symm() [2/2]

template<int _SrcMode, int _DstMode, typename MatrixType , int DstOrder>
void Eigen::internal::permute_symm_to_symm ( const MatrixType mat,
SparseMatrix< typename MatrixType::Scalar, DstOrder, typename MatrixType::StorageIndex > &  _dest,
const typename MatrixType::StorageIndex *  perm 
)

Definition at line 520 of file SparseSelfAdjointView.h.

◆ peven_mask() [1/10]

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::peven_mask ( const Packet16f )

Definition at line 223 of file AVX512/PacketMath.h.

◆ peven_mask() [2/10]

template<>
EIGEN_STRONG_INLINE Packet16i Eigen::internal::peven_mask ( const Packet16i )

Definition at line 227 of file AVX512/PacketMath.h.

◆ peven_mask() [3/10]

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::peven_mask ( const Packet8d )

Definition at line 231 of file AVX512/PacketMath.h.

◆ peven_mask() [4/10]

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::peven_mask ( const Packet8f )

Definition at line 252 of file AVX/PacketMath.h.

◆ peven_mask() [5/10]

template<>
EIGEN_STRONG_INLINE Packet8i Eigen::internal::peven_mask ( const Packet8i )

Definition at line 253 of file AVX/PacketMath.h.

◆ peven_mask() [6/10]

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::peven_mask ( const Packet4d )

Definition at line 254 of file AVX/PacketMath.h.

◆ peven_mask() [7/10]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::peven_mask ( const Packet4f )

Definition at line 266 of file SSE/PacketMath.h.

◆ peven_mask() [8/10]

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::peven_mask ( const Packet4i )

Definition at line 267 of file SSE/PacketMath.h.

◆ peven_mask() [9/10]

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::peven_mask ( const Packet2d )

Definition at line 268 of file SSE/PacketMath.h.

◆ peven_mask() [10/10]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::peven_mask ( const Packet )
inline

Definition at line 684 of file GenericPacketMath.h.

◆ pexp()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pexp ( const Packet a)

Definition at line 788 of file GenericPacketMath.h.

◆ pexp< Packet2d >()

Definition at line 326 of file Eigen/src/Core/arch/MSA/MathFunctions.h.

◆ pexp< Packet2f >()

Definition at line 15 of file Eigen/src/Core/arch/NEON/MathFunctions.h.

◆ pexp< Packet4d >()

Definition at line 86 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ pexp< Packet4f >()

Definition at line 26 of file Eigen/src/Core/arch/AltiVec/MathFunctions.h.

◆ pexp< Packet8bf >()

Definition at line 1350 of file AltiVec/PacketMath.h.

◆ pexp< Packet8f >()

Definition at line 72 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ pexp< PacketXf >()

template<>
EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf Eigen::internal::pexp< PacketXf > ( const PacketXf &  x)

Definition at line 17 of file Eigen/src/Core/arch/SVE/MathFunctions.h.

◆ pexp_double()

template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::pexp_double ( const Packet  _x)

Definition at line 490 of file GenericPacketMathFunctions.h.

◆ pexp_float()

template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::pexp_float ( const Packet  _x)

Definition at line 439 of file GenericPacketMathFunctions.h.

◆ pexpm1()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pexpm1 ( const Packet a)

Definition at line 792 of file GenericPacketMath.h.

◆ pexpm1< Packet4f >()

Definition at line 48 of file Eigen/src/Core/arch/SSE/MathFunctions.h.

◆ pexpm1< Packet8f >()

Definition at line 63 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ pfirst() [1/2]

template<typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits<Packet>::type Eigen::internal::pfirst ( const Packet a)
inline

Definition at line 844 of file GenericPacketMath.h.

◆ pfirst() [2/2]

template<>
EIGEN_STRONG_INLINE bfloat16 Eigen::internal::pfirst ( const Packet8bf a)

Definition at line 1429 of file AltiVec/PacketMath.h.

◆ pfirst< Packet16b >()

Definition at line 889 of file SSE/PacketMath.h.

◆ pfirst< Packet16bf >()

Definition at line 1888 of file AVX512/PacketMath.h.

◆ pfirst< Packet16c >() [1/2]

template<>
EIGEN_STRONG_INLINE signed char Eigen::internal::pfirst< Packet16c > ( const Packet16c a)

Definition at line 1137 of file AltiVec/PacketMath.h.

◆ pfirst< Packet16c >() [2/2]

Definition at line 2283 of file NEON/PacketMath.h.

◆ pfirst< Packet16f >()

template<>
EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet16f > ( const Packet16f a)

Definition at line 863 of file AVX512/PacketMath.h.

◆ pfirst< Packet16h >()

Definition at line 1382 of file AVX512/PacketMath.h.

◆ pfirst< Packet16i >()

Definition at line 871 of file AVX512/PacketMath.h.

◆ pfirst< Packet16uc >() [1/2]

template<>
EIGEN_STRONG_INLINE unsigned char Eigen::internal::pfirst< Packet16uc > ( const Packet16uc a)

Definition at line 1142 of file AltiVec/PacketMath.h.

◆ pfirst< Packet16uc >() [2/2]

Definition at line 2286 of file NEON/PacketMath.h.

◆ pfirst< Packet1cd >()

template<>
EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::pfirst< Packet1cd > ( const Packet1cd a)

Definition at line 584 of file MSA/Complex.h.

◆ pfirst< Packet1cf >()

template<>
EIGEN_STRONG_INLINE std::complex<float> Eigen::internal::pfirst< Packet1cf > ( const Packet1cf a)

Definition at line 277 of file NEON/Complex.h.

◆ pfirst< Packet2cd >()

template<>
EIGEN_STRONG_INLINE std::complex<double> Eigen::internal::pfirst< Packet2cd > ( const Packet2cd a)

Definition at line 295 of file AVX/Complex.h.

◆ pfirst< Packet2cf >()

template<>
EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::pfirst< Packet2cf > ( const Packet2cf a)

Definition at line 176 of file AltiVec/Complex.h.

◆ pfirst< Packet2d >()

template<>
EIGEN_STRONG_INLINE double Eigen::internal::pfirst< Packet2d > ( const Packet2d a)

Definition at line 1061 of file MSA/PacketMath.h.

◆ pfirst< Packet2f >()

template<>
EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet2f > ( const Packet2f a)

Definition at line 2279 of file NEON/PacketMath.h.

◆ pfirst< Packet2i >()

Definition at line 2291 of file NEON/PacketMath.h.

◆ pfirst< Packet2l >()

Definition at line 2295 of file NEON/PacketMath.h.

◆ pfirst< Packet2ui >()

Definition at line 2293 of file NEON/PacketMath.h.

◆ pfirst< Packet2ul >()

Definition at line 2296 of file NEON/PacketMath.h.

◆ pfirst< Packet4bf >()

Definition at line 3427 of file NEON/PacketMath.h.

◆ pfirst< Packet4c >()

Definition at line 2281 of file NEON/PacketMath.h.

◆ pfirst< Packet4cd >()

template<>
EIGEN_STRONG_INLINE std::complex<double> Eigen::internal::pfirst< Packet4cd > ( const Packet4cd a)

Definition at line 288 of file AVX512/Complex.h.

◆ pfirst< Packet4cf >()

template<>
EIGEN_STRONG_INLINE std::complex<float> Eigen::internal::pfirst< Packet4cf > ( const Packet4cf a)

Definition at line 140 of file AVX/Complex.h.

◆ pfirst< Packet4d >()

template<>
EIGEN_STRONG_INLINE double Eigen::internal::pfirst< Packet4d > ( const Packet4d a)

Definition at line 699 of file AVX/PacketMath.h.

◆ pfirst< Packet4f >()

template<>
EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet4f > ( const Packet4f a)

Definition at line 1120 of file AltiVec/PacketMath.h.

◆ pfirst< Packet4i >() [1/2]

Definition at line 530 of file MSA/PacketMath.h.

◆ pfirst< Packet4i >() [2/2]

Definition at line 1121 of file AltiVec/PacketMath.h.

◆ pfirst< Packet4s >()

Definition at line 2287 of file NEON/PacketMath.h.

◆ pfirst< Packet4uc >()

Definition at line 2284 of file NEON/PacketMath.h.

◆ pfirst< Packet4ui >()

Definition at line 2294 of file NEON/PacketMath.h.

◆ pfirst< Packet4us >()

Definition at line 2289 of file NEON/PacketMath.h.

◆ pfirst< Packet8bf >()

Definition at line 1327 of file AVX/PacketMath.h.

◆ pfirst< Packet8c >()

Definition at line 2282 of file NEON/PacketMath.h.

◆ pfirst< Packet8cf >()

template<>
EIGEN_STRONG_INLINE std::complex<float> Eigen::internal::pfirst< Packet8cf > ( const Packet8cf a)

Definition at line 125 of file AVX512/Complex.h.

◆ pfirst< Packet8d >()

template<>
EIGEN_STRONG_INLINE double Eigen::internal::pfirst< Packet8d > ( const Packet8d a)

Definition at line 867 of file AVX512/PacketMath.h.

◆ pfirst< Packet8f >()

template<>
EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet8f > ( const Packet8f a)

Definition at line 696 of file AVX/PacketMath.h.

◆ pfirst< Packet8h >()

Definition at line 942 of file AVX/PacketMath.h.

◆ pfirst< Packet8i >()

Definition at line 702 of file AVX/PacketMath.h.

◆ pfirst< Packet8s >() [1/2]

template<>
EIGEN_STRONG_INLINE short int Eigen::internal::pfirst< Packet8s > ( const Packet8s a)

Definition at line 1129 of file AltiVec/PacketMath.h.

◆ pfirst< Packet8s >() [2/2]

Definition at line 2288 of file NEON/PacketMath.h.

◆ pfirst< Packet8uc >()

Definition at line 2285 of file NEON/PacketMath.h.

◆ pfirst< Packet8us >() [1/2]

template<>
EIGEN_STRONG_INLINE unsigned short int Eigen::internal::pfirst< Packet8us > ( const Packet8us a)

Definition at line 1133 of file AltiVec/PacketMath.h.

◆ pfirst< Packet8us >() [2/2]

Definition at line 2290 of file NEON/PacketMath.h.

◆ pfirst< PacketXf >()

template<>
EIGEN_STRONG_INLINE float Eigen::internal::pfirst< PacketXf > ( const PacketXf &  a)

Definition at line 645 of file SVE/PacketMath.h.

◆ pfirst< PacketXi >()

template<>
EIGEN_STRONG_INLINE numext::int32_t Eigen::internal::pfirst< PacketXi > ( const PacketXi &  a)

Definition at line 279 of file SVE/PacketMath.h.

◆ pfloor()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pfloor ( const Packet a)

Definition at line 830 of file GenericPacketMath.h.

◆ pfloor< Packet16bf >()

Definition at line 2027 of file AVX512/PacketMath.h.

◆ pfloor< Packet16f >()

Definition at line 532 of file AVX512/PacketMath.h.

◆ pfloor< Packet16h >()

Definition at line 1543 of file AVX512/PacketMath.h.

◆ pfloor< Packet2d >()

Definition at line 1163 of file MSA/PacketMath.h.

◆ pfloor< Packet2f >()

Definition at line 3153 of file NEON/PacketMath.h.

◆ pfloor< Packet4bf >()

Definition at line 3526 of file NEON/PacketMath.h.

◆ pfloor< Packet4d >()

Definition at line 456 of file AVX/PacketMath.h.

◆ pfloor< Packet4f >()

Definition at line 939 of file AltiVec/PacketMath.h.

◆ pfloor< Packet8bf >()

Definition at line 1384 of file AltiVec/PacketMath.h.

◆ pfloor< Packet8d >()

Definition at line 533 of file AVX512/PacketMath.h.

◆ pfloor< Packet8f >()

Definition at line 455 of file AVX/PacketMath.h.

◆ pfloor< Packet8h >()

Definition at line 1073 of file AVX/PacketMath.h.

◆ pfloor< PacketXf >()

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::pfloor< PacketXf > ( const PacketXf &  a)

Definition at line 551 of file SVE/PacketMath.h.

◆ pfrexp() [1/4]

template<>
EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pfrexp ( const Packet4bf a,
Packet4bf exponent 
)

Definition at line 48 of file Eigen/src/Core/arch/NEON/MathFunctions.h.

◆ pfrexp() [2/4]

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::pfrexp ( const Packet8h a,
Packet8h exponent 
)

Definition at line 188 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ pfrexp() [3/4]

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pfrexp ( const Packet8bf a,
Packet8bf exponent 
)

Definition at line 212 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ pfrexp() [4/4]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pfrexp ( const Packet a,
Packet exponent 
)
inline

Definition at line 576 of file GenericPacketMath.h.

◆ pfrexp< Packet16f >()

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pfrexp< Packet16f > ( const Packet16f a,
Packet16f exponent 
)

Definition at line 898 of file AVX512/PacketMath.h.

◆ pfrexp< Packet2d >()

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pfrexp< Packet2d > ( const Packet2d a,
Packet2d exponent 
)

Definition at line 918 of file SSE/PacketMath.h.

◆ pfrexp< Packet2f >()

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::pfrexp< Packet2f > ( const Packet2f a,
Packet2f exponent 
)

Definition at line 2377 of file NEON/PacketMath.h.

◆ pfrexp< Packet4d >()

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pfrexp< Packet4d > ( const Packet4d a,
Packet4d exponent 
)

Definition at line 764 of file AVX/PacketMath.h.

◆ pfrexp< Packet4f >()

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pfrexp< Packet4f > ( const Packet4f a,
Packet4f exponent 
)

Definition at line 1361 of file AltiVec/PacketMath.h.

◆ pfrexp< Packet8bf >()

Definition at line 1364 of file AltiVec/PacketMath.h.

◆ pfrexp< Packet8d >()

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pfrexp< Packet8d > ( const Packet8d a,
Packet8d exponent 
)

Definition at line 915 of file AVX512/PacketMath.h.

◆ pfrexp< Packet8f >()

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pfrexp< Packet8f > ( const Packet8f a,
Packet8f exponent 
)

Definition at line 736 of file AVX/PacketMath.h.

◆ pfrexp< PacketXf >()

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::pfrexp< PacketXf > ( const PacketXf &  a,
PacketXf &  exponent 
)

Definition at line 666 of file SVE/PacketMath.h.

◆ pfrexp_generic()

template<typename Packet >
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet Eigen::internal::pfrexp_generic ( const Packet a,
Packet exponent 
)

Default implementation of pfrexp. It is expected to be called by implementers of template<> pfrexp.

Definition at line 40 of file GenericPacketMathFunctions.h.

◆ pfrexp_generic_get_biased_exponent() [1/4]

template<typename Packet >
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet Eigen::internal::pfrexp_generic_get_biased_exponent ( const Packet a)

Definition at line 30 of file GenericPacketMathFunctions.h.

◆ pfrexp_generic_get_biased_exponent() [2/4]

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pfrexp_generic_get_biased_exponent ( const Packet4d a)

Definition at line 743 of file AVX/PacketMath.h.

◆ pfrexp_generic_get_biased_exponent() [3/4]

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pfrexp_generic_get_biased_exponent ( const Packet8d a)

Definition at line 905 of file AVX512/PacketMath.h.

◆ pfrexp_generic_get_biased_exponent() [4/4]

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pfrexp_generic_get_biased_exponent ( const Packet2d a)

Definition at line 912 of file SSE/PacketMath.h.

◆ pgamma_sample_der_alpha()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::pgamma_sample_der_alpha ( const Packet alpha,
const Packet sample 
)

Definition at line 63 of file SpecialFunctionsPacketMath.h.

◆ pgather()

template<typename Scalar , typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pgather ( const Scalar from,
Index   
)
inline

Definition at line 712 of file GenericPacketMath.h.

◆ pgather< bfloat16, Packet16bf >()

Definition at line 2153 of file AVX512/PacketMath.h.

◆ pgather< bfloat16, Packet4bf >()

Definition at line 3555 of file NEON/PacketMath.h.

◆ pgather< bfloat16, Packet8bf >() [1/2]

template<>
EIGEN_DEVICE_FUNC Packet8bf Eigen::internal::pgather< bfloat16, Packet8bf > ( const bfloat16 from,
Index  stride 
)
inline

Definition at line 647 of file AltiVec/PacketMath.h.

◆ pgather< bfloat16, Packet8bf >() [2/2]

Definition at line 1464 of file AVX/PacketMath.h.

◆ pgather< bool, Packet16b >()

template<>
EIGEN_DEVICE_FUNC Packet16b Eigen::internal::pgather< bool, Packet16b > ( const bool *  from,
Index  stride 
)
inline

Definition at line 812 of file SSE/PacketMath.h.

◆ pgather< double, Packet2d >()

template<>
EIGEN_DEVICE_FUNC Packet2d Eigen::internal::pgather< double, Packet2d > ( const double *  from,
Index  stride 
)
inline

Definition at line 1033 of file MSA/PacketMath.h.

◆ pgather< double, Packet4d >()

template<>
EIGEN_DEVICE_FUNC Packet4d Eigen::internal::pgather< double, Packet4d > ( const double *  from,
Index  stride 
)
inline

Definition at line 645 of file AVX/PacketMath.h.

◆ pgather< double, Packet8d >()

template<>
EIGEN_DEVICE_FUNC Packet8d Eigen::internal::pgather< double, Packet8d > ( const double *  from,
Index  stride 
)
inline

Definition at line 813 of file AVX512/PacketMath.h.

◆ pgather< Eigen::half, Packet16h >()

Definition at line 1637 of file AVX512/PacketMath.h.

◆ pgather< Eigen::half, Packet8h >()

Definition at line 1128 of file AVX/PacketMath.h.

◆ pgather< float, Packet16f >()

template<>
EIGEN_DEVICE_FUNC Packet16f Eigen::internal::pgather< float, Packet16f > ( const float *  from,
Index  stride 
)
inline

Definition at line 803 of file AVX512/PacketMath.h.

◆ pgather< float, Packet2f >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2f Eigen::internal::pgather< float, Packet2f > ( const float *  from,
Index  stride 
)

Definition at line 1943 of file NEON/PacketMath.h.

◆ pgather< float, Packet4f >() [1/2]

template<>
EIGEN_DEVICE_FUNC Packet4f Eigen::internal::pgather< float, Packet4f > ( const float *  from,
Index  stride 
)
inline

Definition at line 613 of file AltiVec/PacketMath.h.

◆ pgather< float, Packet4f >() [2/2]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4f Eigen::internal::pgather< float, Packet4f > ( const float *  from,
Index  stride 
)

Definition at line 1949 of file NEON/PacketMath.h.

◆ pgather< float, Packet8f >()

template<>
EIGEN_DEVICE_FUNC Packet8f Eigen::internal::pgather< float, Packet8f > ( const float *  from,
Index  stride 
)
inline

Definition at line 640 of file AVX/PacketMath.h.

◆ pgather< float, PacketXf >()

template<>
EIGEN_DEVICE_FUNC PacketXf Eigen::internal::pgather< float, PacketXf > ( const float *  from,
Index  stride 
)
inline

Definition at line 629 of file SVE/PacketMath.h.

◆ pgather< int, Packet4i >()

template<>
EIGEN_DEVICE_FUNC Packet4i Eigen::internal::pgather< int, Packet4i > ( const int from,
Index  stride 
)
inline

Definition at line 618 of file AltiVec/PacketMath.h.

◆ pgather< int16_t, Packet4s >()

Definition at line 2035 of file NEON/PacketMath.h.

◆ pgather< int16_t, Packet8s >()

Definition at line 2043 of file NEON/PacketMath.h.

◆ pgather< int32_t, Packet2i >()

Definition at line 2075 of file NEON/PacketMath.h.

◆ pgather< int32_t, Packet4i >() [1/2]

template<>
EIGEN_DEVICE_FUNC Packet4i Eigen::internal::pgather< int32_t, Packet4i > ( const int32_t from,
Index  stride 
)
inline

Definition at line 469 of file MSA/PacketMath.h.

◆ pgather< int32_t, Packet4i >() [2/2]

Definition at line 2081 of file NEON/PacketMath.h.

◆ pgather< int64_t, Packet2l >()

Definition at line 2103 of file NEON/PacketMath.h.

◆ pgather< int8_t, Packet16c >()

Definition at line 1976 of file NEON/PacketMath.h.

◆ pgather< int8_t, Packet4c >()

Definition at line 1957 of file NEON/PacketMath.h.

◆ pgather< int8_t, Packet8c >()

Definition at line 1964 of file NEON/PacketMath.h.

◆ pgather< numext::int32_t, PacketXi >()

template<>
EIGEN_DEVICE_FUNC PacketXi Eigen::internal::pgather< numext::int32_t, PacketXi > ( const numext::int32_t from,
Index  stride 
)
inline

Definition at line 263 of file SVE/PacketMath.h.

◆ pgather< short int, Packet8s >()

template<>
EIGEN_DEVICE_FUNC Packet8s Eigen::internal::pgather< short int, Packet8s > ( const short int from,
Index  stride 
)
inline

Definition at line 637 of file AltiVec/PacketMath.h.

◆ pgather< signed char, Packet16c >()

template<>
EIGEN_DEVICE_FUNC Packet16c Eigen::internal::pgather< signed char, Packet16c > ( const signed char *  from,
Index  stride 
)
inline

Definition at line 675 of file AltiVec/PacketMath.h.

◆ pgather< std::complex< double >, Packet1cd >() [1/2]

template<>
EIGEN_DEVICE_FUNC Packet1cd Eigen::internal::pgather< std::complex< double >, Packet1cd > ( const std::complex< double > *  from,
Index stride  EIGEN_UNUSED 
)
inline

Definition at line 109 of file ZVector/Complex.h.

◆ pgather< std::complex< double >, Packet1cd >() [2/2]

template<>
EIGEN_DEVICE_FUNC Packet1cd Eigen::internal::pgather< std::complex< double >, Packet1cd > ( const std::complex< double > *  from,
Index stride   __attribute__(unused) 
)
inline

Definition at line 563 of file MSA/Complex.h.

◆ 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

Definition at line 281 of file AVX/Complex.h.

◆ pgather< std::complex< double >, Packet4cd >()

template<>
EIGEN_DEVICE_FUNC Packet4cd Eigen::internal::pgather< std::complex< double >, Packet4cd > ( const std::complex< double > *  from,
Index  stride 
)
inline

Definition at line 271 of file AVX512/Complex.h.

◆ pgather< std::complex< float >, Packet1cf >()

template<>
EIGEN_DEVICE_FUNC Packet1cf Eigen::internal::pgather< std::complex< float >, Packet1cf > ( const std::complex< float > *  from,
Index  stride 
)
inline

Definition at line 248 of file NEON/Complex.h.

◆ pgather< std::complex< float >, Packet2cf >()

template<>
EIGEN_DEVICE_FUNC Packet2cf Eigen::internal::pgather< std::complex< float >, Packet2cf > ( const std::complex< float > *  from,
Index  stride 
)
inline

Definition at line 149 of file AltiVec/Complex.h.

◆ 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

Definition at line 116 of file AVX/Complex.h.

◆ pgather< std::complex< float >, Packet8cf >()

template<>
EIGEN_DEVICE_FUNC Packet8cf Eigen::internal::pgather< std::complex< float >, Packet8cf > ( const std::complex< float > *  from,
Index  stride 
)
inline

Definition at line 115 of file AVX512/Complex.h.

◆ pgather< uint16_t, Packet4us >()

Definition at line 2055 of file NEON/PacketMath.h.

◆ pgather< uint16_t, Packet8us >()

Definition at line 2063 of file NEON/PacketMath.h.

◆ pgather< uint32_t, Packet2ui >()

Definition at line 2089 of file NEON/PacketMath.h.

◆ pgather< uint32_t, Packet4ui >()

Definition at line 2095 of file NEON/PacketMath.h.

◆ pgather< uint64_t, Packet2ul >()

Definition at line 2109 of file NEON/PacketMath.h.

◆ pgather< uint8_t, Packet16uc >()

Definition at line 2015 of file NEON/PacketMath.h.

◆ pgather< uint8_t, Packet4uc >()

Definition at line 1996 of file NEON/PacketMath.h.

◆ pgather< uint8_t, Packet8uc >()

Definition at line 2003 of file NEON/PacketMath.h.

◆ pgather< unsigned char, Packet16uc >()

template<>
EIGEN_DEVICE_FUNC Packet16uc Eigen::internal::pgather< unsigned char, Packet16uc > ( const unsigned char *  from,
Index  stride 
)
inline

Definition at line 680 of file AltiVec/PacketMath.h.

◆ pgather< unsigned short int, Packet8us >()

template<>
EIGEN_DEVICE_FUNC Packet8us Eigen::internal::pgather< unsigned short int, Packet8us > ( const unsigned short int from,
Index  stride 
)
inline

Definition at line 642 of file AltiVec/PacketMath.h.

◆ pgather_common()

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pgather_common ( const __UNPACK_TYPE__(Packet) *  from,
Index  stride 
)
inline

Definition at line 603 of file AltiVec/PacketMath.h.

◆ pgather_size16()

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pgather_size16 ( const __UNPACK_TYPE__(Packet) *  from,
Index  stride 
)
inline

Definition at line 652 of file AltiVec/PacketMath.h.

◆ pgather_size8()

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pgather_size8 ( const __UNPACK_TYPE__(Packet) *  from,
Index  stride 
)
inline

Definition at line 623 of file AltiVec/PacketMath.h.

◆ pger() [1/2]

template<int N, typename Scalar , typename Packet , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void Eigen::internal::pger ( PacketBlock< Packet, N > *  acc,
const Scalar lhs,
const Packet rhsV 
)

Definition at line 1027 of file MatrixProduct.h.

◆ pger() [2/2]

template<int N, typename Scalar , typename Packet , typename Index , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void Eigen::internal::pger ( PacketBlock< Packet, N > *  acc,
const Scalar lhs,
const Packet rhsV,
Index  remaining_rows 
)

Definition at line 1048 of file MatrixProduct.h.

◆ pger_common() [1/2]

template<typename Packet , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void Eigen::internal::pger_common ( PacketBlock< Packet, 4 > *  acc,
const Packet lhsV,
const Packet rhsV 
)

Definition at line 999 of file MatrixProduct.h.

◆ pger_common() [2/2]

template<typename Packet , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void Eigen::internal::pger_common ( PacketBlock< Packet, 1 > *  acc,
const Packet lhsV,
const Packet rhsV 
)

Definition at line 1016 of file MatrixProduct.h.

◆ pgerc() [1/2]

template<int N, typename Scalar , typename Packet , bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_ALWAYS_INLINE void Eigen::internal::pgerc ( PacketBlock< Packet, N > *  accReal,
PacketBlock< Packet, N > *  accImag,
const Scalar lhs_ptr,
const Scalar lhs_ptr_imag,
const Packet rhsV,
const Packet rhsVi 
)

Definition at line 1077 of file MatrixProduct.h.

◆ pgerc() [2/2]

template<int N, typename Scalar , typename Packet , typename Index , bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_ALWAYS_INLINE void Eigen::internal::pgerc ( PacketBlock< Packet, N > *  accReal,
PacketBlock< Packet, N > *  accImag,
const Scalar lhs_ptr,
const Scalar lhs_ptr_imag,
const Packet rhsV,
const Packet rhsVi,
Index  remaining_rows 
)

Definition at line 1105 of file MatrixProduct.h.

◆ pgerc_common()

template<int N, typename Packet , bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_ALWAYS_INLINE void Eigen::internal::pgerc_common ( PacketBlock< Packet, N > *  accReal,
PacketBlock< Packet, N > *  accImag,
const Packet lhsV,
const Packet lhsVi,
const Packet rhsV,
const Packet rhsVi 
)

Definition at line 1058 of file MatrixProduct.h.

◆ pgercMMA()

template<typename Scalar , typename Packet , typename RhsPacket , bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
EIGEN_ALWAYS_INLINE void Eigen::internal::pgercMMA ( __vector_quad *  accReal,
__vector_quad *  accImag,
const Packet lhsV,
const Packet lhsVi,
const RhsPacket &  rhsV,
const RhsPacket &  rhsVi 
)

Definition at line 108 of file MatrixProductMMA.h.

◆ pgerMMA() [1/4]

template<typename LhsPacket , typename RhsPacket , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void Eigen::internal::pgerMMA ( __vector_quad *  acc,
const RhsPacket &  a,
const LhsPacket &  b 
)

Definition at line 68 of file MatrixProductMMA.h.

◆ pgerMMA() [2/4]

template<typename LhsPacket , typename RhsPacket , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void Eigen::internal::pgerMMA ( __vector_quad *  acc,
const PacketBlock< Packet2d, 2 > &  a,
const Packet2d b 
)

Definition at line 79 of file MatrixProductMMA.h.

◆ pgerMMA() [3/4]

template<typename LhsPacket , typename RhsPacket , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void Eigen::internal::pgerMMA ( __vector_quad *  acc,
const __vector_pair &  a,
const Packet2d b 
)

Definition at line 91 of file MatrixProductMMA.h.

◆ pgerMMA() [4/4]

template<typename LhsPacket , typename RhsPacket , bool NegativeAccumulate>
EIGEN_ALWAYS_INLINE void Eigen::internal::pgerMMA ( __vector_quad *  ,
const __vector_pair &  ,
const Packet4f  
)

Definition at line 102 of file MatrixProductMMA.h.

◆ pigamma()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::pigamma ( const Packet a,
const Packet x 
)

Definition at line 50 of file SpecialFunctionsPacketMath.h.

◆ pigamma_der_a()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::pigamma_der_a ( const Packet a,
const Packet x 
)

Definition at line 55 of file SpecialFunctionsPacketMath.h.

◆ pigammac()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::pigammac ( const Packet a,
const Packet x 
)

Definition at line 69 of file SpecialFunctionsPacketMath.h.

◆ pldexp() [1/4]

template<>
EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pldexp ( const Packet4bf a,
const Packet4bf exponent 
)

Definition at line 56 of file Eigen/src/Core/arch/NEON/MathFunctions.h.

◆ pldexp() [2/4]

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::pldexp ( const Packet8h a,
const Packet8h exponent 
)

Definition at line 196 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ pldexp() [3/4]

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pldexp ( const Packet8bf a,
const Packet8bf exponent 
)

Definition at line 220 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ pldexp() [4/4]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pldexp ( const Packet a,
const Packet exponent 
)
inline

Definition at line 588 of file GenericPacketMath.h.

◆ pldexp< Packet16f >()

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pldexp< Packet16f > ( const Packet16f a,
const Packet16f exponent 
)

Definition at line 919 of file AVX512/PacketMath.h.

◆ pldexp< Packet2d >()

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pldexp< Packet2d > ( const Packet2d a,
const Packet2d exponent 
)

Definition at line 928 of file SSE/PacketMath.h.

◆ pldexp< Packet2f >()

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::pldexp< Packet2f > ( const Packet2f a,
const Packet2f exponent 
)

Definition at line 2382 of file NEON/PacketMath.h.

◆ pldexp< Packet4d >()

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pldexp< Packet4d > ( const Packet4d a,
const Packet4d exponent 
)

Definition at line 772 of file AVX/PacketMath.h.

◆ pldexp< Packet4f >()

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pldexp< Packet4f > ( const Packet4f a,
const Packet4f exponent 
)

Definition at line 1354 of file AltiVec/PacketMath.h.

◆ pldexp< Packet8bf >()

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pldexp< Packet8bf > ( const Packet8bf a,
const Packet8bf exponent 
)

Definition at line 1357 of file AltiVec/PacketMath.h.

◆ pldexp< Packet8d >()

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pldexp< Packet8d > ( const Packet8d a,
const Packet8d exponent 
)

Definition at line 923 of file AVX512/PacketMath.h.

◆ pldexp< Packet8f >()

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pldexp< Packet8f > ( const Packet8f a,
const Packet8f exponent 
)

Definition at line 768 of file AVX/PacketMath.h.

◆ pldexp< PacketXf >()

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::pldexp< PacketXf > ( const PacketXf &  a,
const PacketXf &  exponent 
)

Definition at line 744 of file SVE/PacketMath.h.

◆ pldexp_generic()

template<typename Packet >
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet Eigen::internal::pldexp_generic ( const Packet a,
const Packet exponent 
)

Default implementation of pldexp. It is expected to be called by implementers of template<> pldexp.

Definition at line 85 of file GenericPacketMathFunctions.h.

◆ plgamma()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::plgamma ( const Packet a)

Definition at line 19 of file SpecialFunctionsPacketMath.h.

◆ pload()

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pload ( const typename unpacket_traits< Packet >::type from)
inline

Definition at line 599 of file GenericPacketMath.h.

◆ pload1()

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pload1 ( const typename unpacket_traits< Packet >::type a)
inline

Definition at line 623 of file GenericPacketMath.h.

◆ pload1< Packet16f >()

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pload1< Packet16f > ( const float *  from)

Definition at line 237 of file AVX512/PacketMath.h.

◆ pload1< Packet4d >()

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pload1< Packet4d > ( const double *  from)

Definition at line 257 of file AVX/PacketMath.h.

◆ pload1< Packet4f >()

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pload1< Packet4f > ( const float *  from)

Definition at line 144 of file MSA/PacketMath.h.

◆ pload1< Packet4i >()

Definition at line 153 of file MSA/PacketMath.h.

◆ pload1< Packet8d >()

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pload1< Packet8d > ( const double *  from)

Definition at line 241 of file AVX512/PacketMath.h.

◆ pload1< Packet8f >()

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pload1< Packet8f > ( const float *  from)

Definition at line 256 of file AVX/PacketMath.h.

◆ pload2()

EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pload2 ( const std::complex< float > *  from0,
const std::complex< float > *  from1 
)

Definition at line 130 of file AltiVec/Complex.h.

◆ pload< Packet16b >()

template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::pload< Packet16b > ( const bool *  from)

Definition at line 718 of file SSE/PacketMath.h.

◆ pload< Packet16bf >()

Definition at line 1895 of file AVX512/PacketMath.h.

◆ pload< Packet16c >()

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::pload< Packet16c > ( const signed char *  from)

Definition at line 463 of file AltiVec/PacketMath.h.

◆ pload< Packet16f >()

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pload< Packet16f > ( const float *  from)

Definition at line 679 of file AVX512/PacketMath.h.

◆ pload< Packet16h >()

Definition at line 1386 of file AVX512/PacketMath.h.

◆ pload< Packet16i >()

Definition at line 687 of file AVX512/PacketMath.h.

◆ pload< Packet16uc >()

template<>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pload< Packet16uc > ( const unsigned char *  from)

Definition at line 468 of file AltiVec/PacketMath.h.

◆ pload< Packet1cd >()

template<>
EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pload< Packet1cd > ( const std::complex< double > *  from)

Definition at line 449 of file MSA/Complex.h.

◆ pload< Packet1cf >()

template<>
EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pload< Packet1cf > ( const std::complex< float > *  from)

Definition at line 223 of file NEON/Complex.h.

◆ pload< Packet2cd >()

template<>
EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pload< Packet2cd > ( const std::complex< double > *  from)

Definition at line 264 of file AVX/Complex.h.

◆ pload< Packet2cf >()

template<>
EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pload< Packet2cf > ( const std::complex< float > *  from)

Definition at line 123 of file AltiVec/Complex.h.

◆ pload< Packet2d >()

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pload< Packet2d > ( const double *  from)

Definition at line 967 of file MSA/PacketMath.h.

◆ pload< Packet2f >()

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::pload< Packet2f > ( const float *  from)

Definition at line 1664 of file NEON/PacketMath.h.

◆ pload< Packet2i >()

Definition at line 1696 of file NEON/PacketMath.h.

◆ pload< Packet2l >()

Definition at line 1704 of file NEON/PacketMath.h.

◆ pload< Packet2ui >()

Definition at line 1700 of file NEON/PacketMath.h.

◆ pload< Packet2ul >()

Definition at line 1706 of file NEON/PacketMath.h.

◆ pload< Packet4bf >()

Definition at line 3431 of file NEON/PacketMath.h.

◆ pload< Packet4c >()

Definition at line 1668 of file NEON/PacketMath.h.

◆ pload< Packet4cd >()

template<>
EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pload< Packet4cd > ( const std::complex< double > *  from)

Definition at line 249 of file AVX512/Complex.h.

◆ pload< Packet4cf >()

template<>
EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pload< Packet4cf > ( const std::complex< float > *  from)

Definition at line 96 of file AVX/Complex.h.

◆ pload< Packet4d >()

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pload< Packet4d > ( const double *  from)

Definition at line 578 of file AVX/PacketMath.h.

◆ pload< Packet4f >()

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pload< Packet4f > ( const float *  from)

Definition at line 443 of file AltiVec/PacketMath.h.

◆ pload< Packet4i >() [1/2]

Definition at line 388 of file MSA/PacketMath.h.

◆ pload< Packet4i >() [2/2]

Definition at line 448 of file AltiVec/PacketMath.h.

◆ pload< Packet4s >()

Definition at line 1688 of file NEON/PacketMath.h.

◆ pload< Packet4uc >()

Definition at line 1678 of file NEON/PacketMath.h.

◆ pload< Packet4ui >()

Definition at line 1702 of file NEON/PacketMath.h.

◆ pload< Packet4us >()

Definition at line 1692 of file NEON/PacketMath.h.

◆ pload< Packet8bf >()

Definition at line 473 of file AltiVec/PacketMath.h.

◆ pload< Packet8c >()

Definition at line 1674 of file NEON/PacketMath.h.

◆ pload< Packet8cf >()

template<>
EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pload< Packet8cf > ( const std::complex< float > *  from)

Definition at line 94 of file AVX512/Complex.h.

◆ pload< Packet8d >()

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pload< Packet8d > ( const double *  from)

Definition at line 683 of file AVX512/PacketMath.h.

◆ pload< Packet8f >()

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pload< Packet8f > ( const float *  from)

Definition at line 577 of file AVX/PacketMath.h.

◆ pload< Packet8h >()

Definition at line 946 of file AVX/PacketMath.h.

◆ pload< Packet8i >()

Definition at line 579 of file AVX/PacketMath.h.

◆ pload< Packet8s >() [1/2]

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::pload< Packet8s > ( const short int from)

Definition at line 453 of file AltiVec/PacketMath.h.

◆ pload< Packet8s >() [2/2]

Definition at line 1690 of file NEON/PacketMath.h.

◆ pload< Packet8uc >()

Definition at line 1684 of file NEON/PacketMath.h.

◆ pload< Packet8us >() [1/2]

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::pload< Packet8us > ( const unsigned short int from)

Definition at line 458 of file AltiVec/PacketMath.h.

◆ pload< Packet8us >() [2/2]

Definition at line 1694 of file NEON/PacketMath.h.

◆ pload< PacketXf >()

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::pload< PacketXf > ( const float *  from)

Definition at line 588 of file SVE/PacketMath.h.

◆ pload< PacketXi >()

template<>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::pload< PacketXi > ( const numext::int32_t from)

Definition at line 222 of file SVE/PacketMath.h.

◆ pload_common()

template<typename Packet >
EIGEN_STRONG_INLINE Packet Eigen::internal::pload_common ( const __UNPACK_TYPE__(Packet) *  from)

Definition at line 429 of file AltiVec/PacketMath.h.

◆ ploaddup()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::ploaddup ( const typename unpacket_traits< Packet >::type from)

Definition at line 631 of file GenericPacketMath.h.

◆ ploaddup< Packet16b >()

template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::ploaddup< Packet16b > ( const bool *  from)

Definition at line 774 of file SSE/PacketMath.h.

◆ ploaddup< Packet16bf >()

Definition at line 1917 of file AVX512/PacketMath.h.

◆ ploaddup< Packet16c >()

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::ploaddup< Packet16c > ( const signed char *  from)

Definition at line 1050 of file AltiVec/PacketMath.h.

◆ ploaddup< Packet16f >()

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::ploaddup< Packet16f > ( const float *  from)

Definition at line 715 of file AVX512/PacketMath.h.

◆ ploaddup< Packet16h >()

Definition at line 1407 of file AVX512/PacketMath.h.

◆ ploaddup< Packet16uc >()

template<>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::ploaddup< Packet16uc > ( const unsigned char *  from)

Definition at line 1058 of file AltiVec/PacketMath.h.

◆ ploaddup< Packet1cd >()

template<>
EIGEN_STRONG_INLINE Packet1cd Eigen::internal::ploaddup< Packet1cd > ( const std::complex< double > *  from)

Definition at line 533 of file MSA/Complex.h.

◆ ploaddup< Packet1cf >()

template<>
EIGEN_STRONG_INLINE Packet1cf Eigen::internal::ploaddup< Packet1cf > ( const std::complex< float > *  from)

Definition at line 233 of file NEON/Complex.h.

◆ ploaddup< Packet2cd >()

template<>
EIGEN_STRONG_INLINE Packet2cd Eigen::internal::ploaddup< Packet2cd > ( const std::complex< double > *  from)

Definition at line 276 of file AVX/Complex.h.

◆ ploaddup< Packet2cf >()

template<>
EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploaddup< Packet2cf > ( const std::complex< float > *  from)

Definition at line 125 of file AltiVec/Complex.h.

◆ ploaddup< Packet2d >()

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::ploaddup< Packet2d > ( const double *  from)

Definition at line 1011 of file MSA/PacketMath.h.

◆ ploaddup< Packet2f >()

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::ploaddup< Packet2f > ( const float *  from)

Definition at line 1754 of file NEON/PacketMath.h.

◆ ploaddup< Packet2i >()

Definition at line 1812 of file NEON/PacketMath.h.

◆ ploaddup< Packet2l >()

Definition at line 1820 of file NEON/PacketMath.h.

◆ ploaddup< Packet2ui >()

Definition at line 1816 of file NEON/PacketMath.h.

◆ ploaddup< Packet2ul >()

Definition at line 1822 of file NEON/PacketMath.h.

◆ ploaddup< Packet4bf >()

Definition at line 3451 of file NEON/PacketMath.h.

◆ ploaddup< Packet4c >()

Definition at line 1758 of file NEON/PacketMath.h.

◆ ploaddup< Packet4cd >()

template<>
EIGEN_STRONG_INLINE Packet4cd Eigen::internal::ploaddup< Packet4cd > ( const std::complex< double > *  from)

Definition at line 263 of file AVX512/Complex.h.

◆ ploaddup< Packet4cf >()

template<>
EIGEN_STRONG_INLINE Packet4cf Eigen::internal::ploaddup< Packet4cf > ( const std::complex< float > *  from)

Definition at line 105 of file AVX/Complex.h.

◆ ploaddup< Packet4d >()

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::ploaddup< Packet4d > ( const double *  from)

Definition at line 609 of file AVX/PacketMath.h.

◆ ploaddup< Packet4f >()

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploaddup< Packet4f > ( const float *  from)

Definition at line 1004 of file AltiVec/PacketMath.h.

◆ ploaddup< Packet4i >() [1/2]

Definition at line 419 of file MSA/PacketMath.h.

◆ ploaddup< Packet4i >() [2/2]

Definition at line 1008 of file AltiVec/PacketMath.h.

◆ ploaddup< Packet4s >()

Definition at line 1790 of file NEON/PacketMath.h.

◆ ploaddup< Packet4uc >()

Definition at line 1774 of file NEON/PacketMath.h.

◆ ploaddup< Packet4ui >()

Definition at line 1818 of file NEON/PacketMath.h.

◆ ploaddup< Packet4us >()

Definition at line 1801 of file NEON/PacketMath.h.

◆ ploaddup< Packet8bf >()

Definition at line 1433 of file AltiVec/PacketMath.h.

◆ ploaddup< Packet8c >()

Definition at line 1763 of file NEON/PacketMath.h.

◆ ploaddup< Packet8cf >()

template<>
EIGEN_STRONG_INLINE Packet8cf Eigen::internal::ploaddup< Packet8cf > ( const std::complex< float > *  from)

Definition at line 103 of file AVX512/Complex.h.

◆ ploaddup< Packet8d >()

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::ploaddup< Packet8d > ( const double *  from)

Definition at line 739 of file AVX512/PacketMath.h.

◆ ploaddup< Packet8f >()

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::ploaddup< Packet8f > ( const float *  from)

Definition at line 594 of file AVX/PacketMath.h.

◆ ploaddup< Packet8h >()

Definition at line 963 of file AVX/PacketMath.h.

◆ ploaddup< Packet8s >() [1/2]

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::ploaddup< Packet8s > ( const short int from)

Definition at line 1013 of file AltiVec/PacketMath.h.

◆ ploaddup< Packet8s >() [2/2]

Definition at line 1795 of file NEON/PacketMath.h.

◆ ploaddup< Packet8uc >()

Definition at line 1779 of file NEON/PacketMath.h.

◆ ploaddup< Packet8us >() [1/2]

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::ploaddup< Packet8us > ( const unsigned short int from)

Definition at line 1021 of file AltiVec/PacketMath.h.

◆ ploaddup< Packet8us >() [2/2]

Definition at line 1806 of file NEON/PacketMath.h.

◆ ploaddup< PacketXf >()

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::ploaddup< PacketXf > ( const float *  from)

Definition at line 600 of file SVE/PacketMath.h.

◆ ploaddup< PacketXi >()

template<>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::ploaddup< PacketXi > ( const numext::int32_t from)

Definition at line 234 of file SVE/PacketMath.h.

◆ ploaddup_common()

template<typename Packet >
EIGEN_STRONG_INLINE Packet Eigen::internal::ploaddup_common ( const __UNPACK_TYPE__(Packet) *  from)

Definition at line 997 of file AltiVec/PacketMath.h.

◆ ploadLhs()

template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE Packet Eigen::internal::ploadLhs ( const Scalar lhs)

Definition at line 1114 of file MatrixProduct.h.

◆ ploadquad() [1/3]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::ploadquad ( const typename unpacket_traits< Packet >::type from)
inline

Definition at line 640 of file GenericPacketMath.h.

◆ ploadquad() [2/3]

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::ploadquad ( const Eigen::half from)

Definition at line 1420 of file AVX512/PacketMath.h.

◆ ploadquad() [3/3]

template<>
EIGEN_STRONG_INLINE Packet16bf Eigen::internal::ploadquad ( const bfloat16 from)

Definition at line 1931 of file AVX512/PacketMath.h.

◆ ploadquad< Packet16b >()

template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::ploadquad< Packet16b > ( const bool *  from)

Definition at line 783 of file SSE/PacketMath.h.

◆ ploadquad< Packet16c >()

Definition at line 1834 of file NEON/PacketMath.h.

◆ ploadquad< Packet16f >()

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::ploadquad< Packet16f > ( const float *  from)

Definition at line 752 of file AVX512/PacketMath.h.

◆ ploadquad< Packet16uc >()

Definition at line 1852 of file NEON/PacketMath.h.

◆ ploadquad< Packet4c >()

Definition at line 1826 of file NEON/PacketMath.h.

◆ ploadquad< Packet4f >()

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploadquad< Packet4f > ( const float *  from)

Definition at line 1825 of file NEON/PacketMath.h.

◆ ploadquad< Packet4i >()

Definition at line 1866 of file NEON/PacketMath.h.

◆ ploadquad< Packet4uc >()

Definition at line 1844 of file NEON/PacketMath.h.

◆ ploadquad< Packet4ui >()

Definition at line 1867 of file NEON/PacketMath.h.

◆ ploadquad< Packet8bf >()

Definition at line 1045 of file AltiVec/PacketMath.h.

◆ ploadquad< Packet8c >()

Definition at line 1828 of file NEON/PacketMath.h.

◆ ploadquad< Packet8cf >()

template<>
EIGEN_STRONG_INLINE Packet8cf Eigen::internal::ploadquad< Packet8cf > ( const std::complex< float > *  from)

Definition at line 107 of file AVX512/Complex.h.

◆ ploadquad< Packet8d >()

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::ploadquad< Packet8d > ( const double *  from)

Definition at line 761 of file AVX512/PacketMath.h.

◆ ploadquad< Packet8f >()

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::ploadquad< Packet8f > ( const float *  from)

Definition at line 616 of file AVX/PacketMath.h.

◆ ploadquad< Packet8h >()

Definition at line 972 of file AVX/PacketMath.h.

◆ ploadquad< Packet8s >() [1/2]

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::ploadquad< Packet8s > ( const short int from)

Definition at line 1029 of file AltiVec/PacketMath.h.

◆ ploadquad< Packet8s >() [2/2]

Definition at line 1862 of file NEON/PacketMath.h.

◆ ploadquad< Packet8uc >()

Definition at line 1846 of file NEON/PacketMath.h.

◆ ploadquad< Packet8us >() [1/2]

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::ploadquad< Packet8us > ( const unsigned short int from)

Definition at line 1037 of file AltiVec/PacketMath.h.

◆ ploadquad< Packet8us >() [2/2]

Definition at line 1864 of file NEON/PacketMath.h.

◆ ploadquad< PacketXf >()

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::ploadquad< PacketXf > ( const float *  from)

Definition at line 608 of file SVE/PacketMath.h.

◆ ploadquad< PacketXi >()

template<>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::ploadquad< PacketXi > ( const numext::int32_t from)

Definition at line 242 of file SVE/PacketMath.h.

◆ ploadRhs()

template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE Packet Eigen::internal::ploadRhs ( const Scalar rhs)

Definition at line 215 of file MatrixProductCommon.h.

◆ ploadRhsMMA() [1/2]

template<typename Scalar , typename Packet >
EIGEN_ALWAYS_INLINE void Eigen::internal::ploadRhsMMA ( const Scalar rhs,
Packet rhsV 
)

Definition at line 126 of file MatrixProductMMA.h.

◆ ploadRhsMMA() [2/2]

template<>
EIGEN_ALWAYS_INLINE void Eigen::internal::ploadRhsMMA ( const float *  ,
__vector_pair &   
)

Definition at line 151 of file MatrixProductMMA.h.

◆ ploadRhsMMA< double, __vector_pair >()

template<>
EIGEN_ALWAYS_INLINE void Eigen::internal::ploadRhsMMA< double, __vector_pair > ( const double *  rhs,
__vector_pair &  rhsV 
)

Definition at line 139 of file MatrixProductMMA.h.

◆ ploadRhsMMA< double, PacketBlock< Packet2d, 2 > >()

template<>
EIGEN_ALWAYS_INLINE void Eigen::internal::ploadRhsMMA< double, PacketBlock< Packet2d, 2 > > ( const double *  rhs,
PacketBlock< Packet2d, 2 > &  rhsV 
)

Definition at line 132 of file MatrixProductMMA.h.

◆ ploadt() [1/2]

template<typename packet_type , int Alignment>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type Eigen::internal::ploadt ( const Eigen::TensorSycl::internal::RangeAccess< cl::sycl::access::mode::read_write, typename unpacket_traits< packet_type >::type > &  from)

Definition at line 117 of file SYCL/PacketMath.h.

◆ ploadt() [2/2]

template<typename Packet , int Alignment>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet Eigen::internal::ploadt ( const typename unpacket_traits< Packet >::type from)

Definition at line 964 of file GenericPacketMath.h.

◆ ploadt_ro() [1/2]

template<typename packet_type , int Alignment, typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type Eigen::internal::ploadt_ro ( const Eigen::TensorSycl::internal::RangeAccess< cl::sycl::access::mode::read_write, T > &  from)

Definition at line 53 of file SYCL/PacketMath.h.

◆ ploadt_ro() [2/2]

template<typename Packet , int LoadMode>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet Eigen::internal::ploadt_ro ( const typename unpacket_traits< Packet >::type from)

Definition at line 989 of file GenericPacketMath.h.

◆ ploadu() [1/2]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::ploadu ( const typename unpacket_traits< Packet >::type from)
inline

Definition at line 603 of file GenericPacketMath.h.

◆ ploadu() [2/2]

template<typename Packet >
EIGEN_DEVICE_FUNC enable_if<unpacket_traits<Packet>::masked_load_available, Packet>::type Eigen::internal::ploadu ( const typename unpacket_traits< Packet >::type from,
typename unpacket_traits< Packet >::mask_t  umask 
)
inline

◆ ploadu< Packet16b >()

template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::ploadu< Packet16b > ( const bool *  from)

Definition at line 753 of file SSE/PacketMath.h.

◆ ploadu< Packet16bf >()

Definition at line 1900 of file AVX512/PacketMath.h.

◆ ploadu< Packet16c >()

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::ploadu< Packet16c > ( const signed char *  from)

Definition at line 988 of file AltiVec/PacketMath.h.

◆ ploadu< Packet16f >() [1/2]

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::ploadu< Packet16f > ( const float *  from)

Definition at line 693 of file AVX512/PacketMath.h.

◆ ploadu< Packet16f >() [2/2]

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::ploadu< Packet16f > ( const float *  from,
uint16_t  umask 
)

Definition at line 707 of file AVX512/PacketMath.h.

◆ ploadu< Packet16h >()

Definition at line 1390 of file AVX512/PacketMath.h.

◆ ploadu< Packet16i >()

Definition at line 701 of file AVX512/PacketMath.h.

◆ ploadu< Packet16uc >()

template<>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::ploadu< Packet16uc > ( const unsigned char *  from)

Definition at line 992 of file AltiVec/PacketMath.h.

◆ ploadu< Packet1cd >()

template<>
EIGEN_STRONG_INLINE Packet1cd Eigen::internal::ploadu< Packet1cd > ( const std::complex< double > *  from)

Definition at line 456 of file MSA/Complex.h.

◆ ploadu< Packet1cf >()

template<>
EIGEN_STRONG_INLINE Packet1cf Eigen::internal::ploadu< Packet1cf > ( const std::complex< float > *  from)

Definition at line 228 of file NEON/Complex.h.

◆ ploadu< Packet2cd >()

template<>
EIGEN_STRONG_INLINE Packet2cd Eigen::internal::ploadu< Packet2cd > ( const std::complex< double > *  from)

Definition at line 266 of file AVX/Complex.h.

◆ ploadu< Packet2cf >()

template<>
EIGEN_STRONG_INLINE Packet2cf Eigen::internal::ploadu< Packet2cf > ( const std::complex< float > *  from)

Definition at line 124 of file AltiVec/Complex.h.

◆ ploadu< Packet2d >()

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::ploadu< Packet2d > ( const double *  from)

Definition at line 1004 of file MSA/PacketMath.h.

◆ ploadu< Packet2f >()

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::ploadu< Packet2f > ( const float *  from)

Definition at line 1709 of file NEON/PacketMath.h.

◆ ploadu< Packet2i >()

Definition at line 1741 of file NEON/PacketMath.h.

◆ ploadu< Packet2l >()

Definition at line 1749 of file NEON/PacketMath.h.

◆ ploadu< Packet2ui >()

Definition at line 1745 of file NEON/PacketMath.h.

◆ ploadu< Packet2ul >()

Definition at line 1751 of file NEON/PacketMath.h.

◆ ploadu< Packet4bf >()

Definition at line 3436 of file NEON/PacketMath.h.

◆ ploadu< Packet4c >()

Definition at line 1713 of file NEON/PacketMath.h.

◆ ploadu< Packet4cd >()

template<>
EIGEN_STRONG_INLINE Packet4cd Eigen::internal::ploadu< Packet4cd > ( const std::complex< double > *  from)

Definition at line 251 of file AVX512/Complex.h.

◆ ploadu< Packet4cf >()

template<>
EIGEN_STRONG_INLINE Packet4cf Eigen::internal::ploadu< Packet4cf > ( const std::complex< float > *  from)

Definition at line 97 of file AVX/Complex.h.

◆ ploadu< Packet4d >()

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::ploadu< Packet4d > ( const double *  from)

Definition at line 582 of file AVX/PacketMath.h.

◆ ploadu< Packet4f >()

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploadu< Packet4f > ( const float *  from)

Definition at line 968 of file AltiVec/PacketMath.h.

◆ ploadu< Packet4i >() [1/2]

Definition at line 402 of file MSA/PacketMath.h.

◆ ploadu< Packet4i >() [2/2]

Definition at line 972 of file AltiVec/PacketMath.h.

◆ ploadu< Packet4s >()

Definition at line 1733 of file NEON/PacketMath.h.

◆ ploadu< Packet4uc >()

Definition at line 1723 of file NEON/PacketMath.h.

◆ ploadu< Packet4ui >()

Definition at line 1747 of file NEON/PacketMath.h.

◆ ploadu< Packet4us >()

Definition at line 1737 of file NEON/PacketMath.h.

◆ ploadu< Packet8bf >()

Definition at line 984 of file AltiVec/PacketMath.h.

◆ ploadu< Packet8c >()

Definition at line 1719 of file NEON/PacketMath.h.

◆ ploadu< Packet8cf >()

template<>
EIGEN_STRONG_INLINE Packet8cf Eigen::internal::ploadu< Packet8cf > ( const std::complex< float > *  from)

Definition at line 95 of file AVX512/Complex.h.

◆ ploadu< Packet8d >()

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::ploadu< Packet8d > ( const double *  from)

Definition at line 697 of file AVX512/PacketMath.h.

◆ ploadu< Packet8f >() [1/2]

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::ploadu< Packet8f > ( const float *  from)

Definition at line 581 of file AVX/PacketMath.h.

◆ ploadu< Packet8f >() [2/2]

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::ploadu< Packet8f > ( const float *  from,
uint8_t  umask 
)

Definition at line 585 of file AVX/PacketMath.h.

◆ ploadu< Packet8h >()

Definition at line 950 of file AVX/PacketMath.h.

◆ ploadu< Packet8i >()

Definition at line 583 of file AVX/PacketMath.h.

◆ ploadu< Packet8s >() [1/2]

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::ploadu< Packet8s > ( const short int from)

Definition at line 976 of file AltiVec/PacketMath.h.

◆ ploadu< Packet8s >() [2/2]

Definition at line 1735 of file NEON/PacketMath.h.

◆ ploadu< Packet8uc >()

Definition at line 1729 of file NEON/PacketMath.h.

◆ ploadu< Packet8us >() [1/2]

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::ploadu< Packet8us > ( const unsigned short int from)

Definition at line 980 of file AltiVec/PacketMath.h.

◆ ploadu< Packet8us >() [2/2]

Definition at line 1739 of file NEON/PacketMath.h.

◆ ploadu< PacketXf >()

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::ploadu< PacketXf > ( const float *  from)

Definition at line 594 of file SVE/PacketMath.h.

◆ ploadu< PacketXi >()

template<>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::ploadu< PacketXi > ( const numext::int32_t from)

Definition at line 228 of file SVE/PacketMath.h.

◆ ploadu_common()

template<typename Packet >
EIGEN_STRONG_INLINE Packet Eigen::internal::ploadu_common ( const __UNPACK_TYPE__(Packet) *  from)

Definition at line 951 of file AltiVec/PacketMath.h.

◆ plog()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::plog ( const Packet a)

Definition at line 796 of file GenericPacketMath.h.

◆ plog10()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::plog10 ( const Packet a)

Definition at line 804 of file GenericPacketMath.h.

◆ plog1p()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::plog1p ( const Packet a)

Definition at line 800 of file GenericPacketMath.h.

◆ plog1p< Packet4f >()

Definition at line 43 of file Eigen/src/Core/arch/SSE/MathFunctions.h.

◆ plog1p< Packet8f >()

Definition at line 58 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ plog2()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::plog2 ( const Packet a)

Definition at line 808 of file GenericPacketMath.h.

◆ plog2< Packet2d >()

Definition at line 38 of file Eigen/src/Core/arch/SSE/MathFunctions.h.

◆ plog2< Packet4d >()

Definition at line 53 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ plog2< Packet4f >()

Definition at line 33 of file Eigen/src/Core/arch/SSE/MathFunctions.h.

◆ plog2< Packet8f >()

Definition at line 47 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ plog2_double()

template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::plog2_double ( const Packet  _x)

Definition at line 383 of file GenericPacketMathFunctions.h.

◆ plog2_float()

template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::plog2_float ( const Packet  _x)

Definition at line 262 of file GenericPacketMathFunctions.h.

◆ plog< Packet2d >()

Definition at line 28 of file Eigen/src/Core/arch/SSE/MathFunctions.h.

◆ plog< Packet2f >()

Definition at line 20 of file Eigen/src/Core/arch/NEON/MathFunctions.h.

◆ plog< Packet4d >()

Definition at line 41 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ plog< Packet4f >()

Definition at line 20 of file Eigen/src/Core/arch/AltiVec/MathFunctions.h.

◆ plog< Packet8bf >()

Definition at line 1381 of file AltiVec/PacketMath.h.

◆ plog< Packet8f >()

Definition at line 35 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ plog< PacketXf >()

template<>
EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf Eigen::internal::plog< PacketXf > ( const PacketXf &  x)

Definition at line 22 of file Eigen/src/Core/arch/SVE/MathFunctions.h.

◆ plog_double()

template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::plog_double ( const Packet  _x)

Definition at line 375 of file GenericPacketMathFunctions.h.

◆ plog_float()

template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::plog_float ( const Packet  _x)

Definition at line 254 of file GenericPacketMathFunctions.h.

◆ plog_impl_double()

template<typename Packet , bool base2>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::plog_impl_double ( const Packet  _x)

Definition at line 279 of file GenericPacketMathFunctions.h.

◆ plog_impl_float()

template<typename Packet , bool base2>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::plog_impl_float ( const Packet  _x)

Definition at line 169 of file GenericPacketMathFunctions.h.

◆ plogical_shift_left() [1/25]

template<int N>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::plogical_shift_left ( PacketXi  a)

Definition at line 216 of file SVE/PacketMath.h.

◆ plogical_shift_left() [2/25]

template<int N>
EIGEN_STRONG_INLINE Packet8i Eigen::internal::plogical_shift_left ( Packet8i  a)

Definition at line 567 of file AVX/PacketMath.h.

◆ plogical_shift_left() [3/25]

template<int N>
EIGEN_DEVICE_FUNC int Eigen::internal::plogical_shift_left ( const int a)
inline

Definition at line 568 of file GenericPacketMath.h.

◆ plogical_shift_left() [4/25]

template<int N>
EIGEN_DEVICE_FUNC long int Eigen::internal::plogical_shift_left ( const long int a)
inline

Definition at line 570 of file GenericPacketMath.h.

◆ plogical_shift_left() [5/25]

template<int N>
EIGEN_STRONG_INLINE Packet16i Eigen::internal::plogical_shift_left ( Packet16i  a)

Definition at line 674 of file AVX512/PacketMath.h.

◆ plogical_shift_left() [6/25]

template<int N>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::plogical_shift_left ( const Packet4i a)

Definition at line 1191 of file AltiVec/PacketMath.h.

◆ plogical_shift_left() [7/25]

template<int N>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::plogical_shift_left ( const Packet4f a)

Definition at line 1193 of file AltiVec/PacketMath.h.

◆ plogical_shift_left() [8/25]

template<int N>
EIGEN_STRONG_INLINE Packet4ui Eigen::internal::plogical_shift_left ( const Packet4ui a)

Definition at line 1213 of file AltiVec/PacketMath.h.

◆ plogical_shift_left() [9/25]

template<int N>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::plogical_shift_left ( const Packet8us a)

Definition at line 1219 of file AltiVec/PacketMath.h.

◆ plogical_shift_left() [10/25]

template<int N>
EIGEN_STRONG_INLINE Packet4c Eigen::internal::plogical_shift_left ( Packet4c a)

Definition at line 1645 of file NEON/PacketMath.h.

◆ plogical_shift_left() [11/25]

template<int N>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::plogical_shift_left ( Packet8c  a)

Definition at line 1647 of file NEON/PacketMath.h.

◆ plogical_shift_left() [12/25]

template<int N>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::plogical_shift_left ( Packet16c  a)

Definition at line 1648 of file NEON/PacketMath.h.

◆ plogical_shift_left() [13/25]

template<int N>
EIGEN_STRONG_INLINE Packet4uc Eigen::internal::plogical_shift_left ( Packet4uc a)

Definition at line 1649 of file NEON/PacketMath.h.

◆ plogical_shift_left() [14/25]

template<int N>
EIGEN_STRONG_INLINE Packet8uc Eigen::internal::plogical_shift_left ( Packet8uc  a)

Definition at line 1651 of file NEON/PacketMath.h.

◆ plogical_shift_left() [15/25]

template<int N>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::plogical_shift_left ( Packet16uc  a)

Definition at line 1652 of file NEON/PacketMath.h.

◆ plogical_shift_left() [16/25]

template<int N>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::plogical_shift_left ( Packet4s  a)

Definition at line 1653 of file NEON/PacketMath.h.

◆ plogical_shift_left() [17/25]

template<int N>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::plogical_shift_left ( Packet8s  a)

Definition at line 1654 of file NEON/PacketMath.h.

◆ plogical_shift_left() [18/25]

template<int N>
EIGEN_STRONG_INLINE Packet4us Eigen::internal::plogical_shift_left ( Packet4us  a)

Definition at line 1655 of file NEON/PacketMath.h.

◆ plogical_shift_left() [19/25]

template<int N>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::plogical_shift_left ( Packet8us  a)

Definition at line 1656 of file NEON/PacketMath.h.

◆ plogical_shift_left() [20/25]

template<int N>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::plogical_shift_left ( Packet2i  a)

Definition at line 1657 of file NEON/PacketMath.h.

◆ plogical_shift_left() [21/25]

template<int N>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::plogical_shift_left ( Packet4i  a)

Definition at line 1658 of file NEON/PacketMath.h.

◆ plogical_shift_left() [22/25]

template<int N>
EIGEN_STRONG_INLINE Packet2ui Eigen::internal::plogical_shift_left ( Packet2ui  a)

Definition at line 1659 of file NEON/PacketMath.h.

◆ plogical_shift_left() [23/25]

template<int N>
EIGEN_STRONG_INLINE Packet4ui Eigen::internal::plogical_shift_left ( Packet4ui  a)

Definition at line 1660 of file NEON/PacketMath.h.

◆ plogical_shift_left() [24/25]

template<int N>
EIGEN_STRONG_INLINE Packet2l Eigen::internal::plogical_shift_left ( Packet2l  a)

Definition at line 1661 of file NEON/PacketMath.h.

◆ plogical_shift_left() [25/25]

template<int N>
EIGEN_STRONG_INLINE Packet2ul Eigen::internal::plogical_shift_left ( Packet2ul  a)

Definition at line 1662 of file NEON/PacketMath.h.

◆ plogical_shift_right() [1/25]

template<int N>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::plogical_shift_right ( PacketXi  a)

Definition at line 210 of file SVE/PacketMath.h.

◆ plogical_shift_right() [2/25]

template<int N>
EIGEN_STRONG_INLINE Packet8i Eigen::internal::plogical_shift_right ( Packet8i  a)

Definition at line 557 of file AVX/PacketMath.h.

◆ plogical_shift_right() [3/25]

template<int N>
EIGEN_DEVICE_FUNC int Eigen::internal::plogical_shift_right ( const int a)
inline

Definition at line 562 of file GenericPacketMath.h.

◆ plogical_shift_right() [4/25]

template<int N>
EIGEN_DEVICE_FUNC long int Eigen::internal::plogical_shift_right ( const long int a)
inline

Definition at line 564 of file GenericPacketMath.h.

◆ plogical_shift_right() [5/25]

template<int N>
EIGEN_STRONG_INLINE Packet16i Eigen::internal::plogical_shift_right ( Packet16i  a)

Definition at line 670 of file AVX512/PacketMath.h.

◆ plogical_shift_right() [6/25]

template<int N>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::plogical_shift_right ( const Packet4i a)

Definition at line 1189 of file AltiVec/PacketMath.h.

◆ plogical_shift_right() [7/25]

template<int N>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::plogical_shift_right ( const Packet4f a)

Definition at line 1200 of file AltiVec/PacketMath.h.

◆ plogical_shift_right() [8/25]

template<int N>
EIGEN_STRONG_INLINE Packet4ui Eigen::internal::plogical_shift_right ( const Packet4ui a)

Definition at line 1207 of file AltiVec/PacketMath.h.

◆ plogical_shift_right() [9/25]

template<int N>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::plogical_shift_right ( const Packet8us a)

Definition at line 1224 of file AltiVec/PacketMath.h.

◆ plogical_shift_right() [10/25]

template<int N>
EIGEN_STRONG_INLINE Packet4c Eigen::internal::plogical_shift_right ( Packet4c a)

Definition at line 1619 of file NEON/PacketMath.h.

◆ plogical_shift_right() [11/25]

template<int N>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::plogical_shift_right ( Packet8c  a)

Definition at line 1621 of file NEON/PacketMath.h.

◆ plogical_shift_right() [12/25]

template<int N>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::plogical_shift_right ( Packet16c  a)

Definition at line 1623 of file NEON/PacketMath.h.

◆ plogical_shift_right() [13/25]

template<int N>
EIGEN_STRONG_INLINE Packet4uc Eigen::internal::plogical_shift_right ( Packet4uc a)

Definition at line 1625 of file NEON/PacketMath.h.

◆ plogical_shift_right() [14/25]

template<int N>
EIGEN_STRONG_INLINE Packet8uc Eigen::internal::plogical_shift_right ( Packet8uc  a)

Definition at line 1627 of file NEON/PacketMath.h.

◆ plogical_shift_right() [15/25]

template<int N>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::plogical_shift_right ( Packet16uc  a)

Definition at line 1628 of file NEON/PacketMath.h.

◆ plogical_shift_right() [16/25]

template<int N>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::plogical_shift_right ( Packet4s  a)

Definition at line 1629 of file NEON/PacketMath.h.

◆ plogical_shift_right() [17/25]

template<int N>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::plogical_shift_right ( Packet8s  a)

Definition at line 1631 of file NEON/PacketMath.h.

◆ plogical_shift_right() [18/25]

template<int N>
EIGEN_STRONG_INLINE Packet4us Eigen::internal::plogical_shift_right ( Packet4us  a)

Definition at line 1633 of file NEON/PacketMath.h.

◆ plogical_shift_right() [19/25]

template<int N>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::plogical_shift_right ( Packet8us  a)

Definition at line 1634 of file NEON/PacketMath.h.

◆ plogical_shift_right() [20/25]

template<int N>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::plogical_shift_right ( Packet2i  a)

Definition at line 1635 of file NEON/PacketMath.h.

◆ plogical_shift_right() [21/25]

template<int N>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::plogical_shift_right ( Packet4i  a)

Definition at line 1637 of file NEON/PacketMath.h.

◆ plogical_shift_right() [22/25]

template<int N>
EIGEN_STRONG_INLINE Packet2ui Eigen::internal::plogical_shift_right ( Packet2ui  a)

Definition at line 1639 of file NEON/PacketMath.h.

◆ plogical_shift_right() [23/25]

template<int N>
EIGEN_STRONG_INLINE Packet4ui Eigen::internal::plogical_shift_right ( Packet4ui  a)

Definition at line 1640 of file NEON/PacketMath.h.

◆ plogical_shift_right() [24/25]

template<int N>
EIGEN_STRONG_INLINE Packet2l Eigen::internal::plogical_shift_right ( Packet2l  a)

Definition at line 1641 of file NEON/PacketMath.h.

◆ plogical_shift_right() [25/25]

template<int N>
EIGEN_STRONG_INLINE Packet2ul Eigen::internal::plogical_shift_right ( Packet2ul  a)

Definition at line 1643 of file NEON/PacketMath.h.

◆ plset()

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::plset ( const typename unpacket_traits< Packet >::type a)

Definition at line 679 of file GenericPacketMath.h.

◆ plset< Packet16bf >()

Definition at line 2109 of file AVX512/PacketMath.h.

◆ plset< Packet16c >()

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::plset< Packet16c > ( const signed char &  a)

Definition at line 771 of file AltiVec/PacketMath.h.

◆ plset< Packet16f >()

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::plset< Packet16f > ( const float &  a)

Definition at line 246 of file AVX512/PacketMath.h.

◆ plset< Packet16h >()

Definition at line 1508 of file AVX512/PacketMath.h.

◆ plset< Packet16uc >()

template<>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::plset< Packet16uc > ( const unsigned char &  a)

Definition at line 772 of file AltiVec/PacketMath.h.

◆ plset< Packet2d >()

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::plset< Packet2d > ( const double &  a)

Definition at line 887 of file MSA/PacketMath.h.

◆ plset< Packet2f >()

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::plset< Packet2f > ( const float &  a)

Definition at line 720 of file NEON/PacketMath.h.

◆ plset< Packet2i >()

Definition at line 774 of file NEON/PacketMath.h.

◆ plset< Packet2l >()

Definition at line 794 of file NEON/PacketMath.h.

◆ plset< Packet2ui >()

Definition at line 784 of file NEON/PacketMath.h.

◆ plset< Packet2ul >()

Definition at line 799 of file NEON/PacketMath.h.

◆ plset< Packet4bf >()

Definition at line 3494 of file NEON/PacketMath.h.

◆ plset< Packet4c >()

Definition at line 730 of file NEON/PacketMath.h.

◆ plset< Packet4d >()

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::plset< Packet4d > ( const double &  a)

Definition at line 260 of file AVX/PacketMath.h.

◆ plset< Packet4f >()

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::plset< Packet4f > ( const float &  a)

Definition at line 767 of file AltiVec/PacketMath.h.

◆ plset< Packet4i >() [1/2]

Definition at line 182 of file MSA/PacketMath.h.

◆ plset< Packet4i >() [2/2]

Definition at line 768 of file AltiVec/PacketMath.h.

◆ plset< Packet4s >()

Definition at line 754 of file NEON/PacketMath.h.

◆ plset< Packet4uc >()

Definition at line 742 of file NEON/PacketMath.h.

◆ plset< Packet4ui >()

Definition at line 789 of file NEON/PacketMath.h.

◆ plset< Packet4us >()

Definition at line 759 of file NEON/PacketMath.h.

◆ plset< Packet8bf >()

Definition at line 1438 of file AltiVec/PacketMath.h.

◆ plset< Packet8c >()

Definition at line 732 of file NEON/PacketMath.h.

◆ plset< Packet8d >()

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::plset< Packet8d > ( const double &  a)

Definition at line 253 of file AVX512/PacketMath.h.

◆ plset< Packet8f >()

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::plset< Packet8f > ( const float &  a)

Definition at line 259 of file AVX/PacketMath.h.

◆ plset< Packet8h >()

Definition at line 1038 of file AVX/PacketMath.h.

◆ plset< Packet8s >() [1/2]

Definition at line 764 of file NEON/PacketMath.h.

◆ plset< Packet8s >() [2/2]

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::plset< Packet8s > ( const short int a)

Definition at line 769 of file AltiVec/PacketMath.h.

◆ plset< Packet8uc >()

Definition at line 744 of file NEON/PacketMath.h.

◆ plset< Packet8us >() [1/2]

Definition at line 769 of file NEON/PacketMath.h.

◆ plset< Packet8us >() [2/2]

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::plset< Packet8us > ( const unsigned short int a)

Definition at line 770 of file AltiVec/PacketMath.h.

◆ plset< PacketXf >()

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::plset< PacketXf > ( const float &  a)

Definition at line 436 of file SVE/PacketMath.h.

◆ plset< PacketXi >()

template<>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::plset< PacketXi > ( const numext::int32_t a)

Definition at line 88 of file SVE/PacketMath.h.

◆ pmadd() [1/21]

template<>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::pmadd ( const PacketXi &  a,
const PacketXi &  b,
const PacketXi &  c 
)

Definition at line 132 of file SVE/PacketMath.h.

◆ pmadd() [2/21]

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::pmadd ( const PacketXf &  a,
const PacketXf &  b,
const PacketXf &  c 
)

Definition at line 480 of file SVE/PacketMath.h.

◆ pmadd() [3/21]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmadd ( const Packet4f a,
const Packet4f b,
const Packet4f c 
)

Definition at line 827 of file AltiVec/PacketMath.h.

◆ pmadd() [4/21]

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmadd ( const Packet4i a,
const Packet4i b,
const Packet4i c 
)

Definition at line 828 of file AltiVec/PacketMath.h.

◆ pmadd() [5/21]

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::pmadd ( const Packet8s a,
const Packet8s b,
const Packet8s c 
)

Definition at line 829 of file AltiVec/PacketMath.h.

◆ pmadd() [6/21]

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::pmadd ( const Packet8us a,
const Packet8us b,
const Packet8us c 
)

Definition at line 830 of file AltiVec/PacketMath.h.

◆ pmadd() [7/21]

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmadd ( const Packet2d a,
const Packet2d b,
const Packet2d c 
)

Definition at line 930 of file MSA/PacketMath.h.

◆ pmadd() [8/21]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pmadd ( const Packet a,
const Packet b,
const Packet c 
)
inline

Definition at line 956 of file GenericPacketMath.h.

◆ pmadd() [9/21]

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::pmadd ( const Packet2f a,
const Packet2f b,
const Packet2f c 
)

Definition at line 1093 of file NEON/PacketMath.h.

◆ pmadd() [10/21]

template<>
EIGEN_STRONG_INLINE Packet4c Eigen::internal::pmadd ( const Packet4c a,
const Packet4c b,
const Packet4c c 
)

Definition at line 1100 of file NEON/PacketMath.h.

◆ pmadd() [11/21]

template<>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::pmadd ( const Packet8c a,
const Packet8c b,
const Packet8c c 
)

Definition at line 1107 of file NEON/PacketMath.h.

◆ pmadd() [12/21]

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::pmadd ( const Packet16c a,
const Packet16c b,
const Packet16c c 
)

Definition at line 1109 of file NEON/PacketMath.h.

◆ pmadd() [13/21]

template<>
EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pmadd ( const Packet4uc a,
const Packet4uc b,
const Packet4uc c 
)

Definition at line 1111 of file NEON/PacketMath.h.

◆ pmadd() [14/21]

template<>
EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pmadd ( const Packet8uc a,
const Packet8uc b,
const Packet8uc c 
)

Definition at line 1118 of file NEON/PacketMath.h.

◆ pmadd() [15/21]

template<>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pmadd ( const Packet16uc a,
const Packet16uc b,
const Packet16uc c 
)

Definition at line 1120 of file NEON/PacketMath.h.

◆ pmadd() [16/21]

template<>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::pmadd ( const Packet4s a,
const Packet4s b,
const Packet4s c 
)

Definition at line 1122 of file NEON/PacketMath.h.

◆ pmadd() [17/21]

template<>
EIGEN_STRONG_INLINE Packet4us Eigen::internal::pmadd ( const Packet4us a,
const Packet4us b,
const Packet4us c 
)

Definition at line 1126 of file NEON/PacketMath.h.

◆ pmadd() [18/21]

template<>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::pmadd ( const Packet2i a,
const Packet2i b,
const Packet2i c 
)

Definition at line 1130 of file NEON/PacketMath.h.

◆ pmadd() [19/21]

template<>
EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pmadd ( const Packet2ui a,
const Packet2ui b,
const Packet2ui c 
)

Definition at line 1134 of file NEON/PacketMath.h.

◆ pmadd() [20/21]

template<>
EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pmadd ( const Packet4ui a,
const Packet4ui b,
const Packet4ui c 
)

Definition at line 1136 of file NEON/PacketMath.h.

◆ pmadd() [21/21]

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pmadd ( const Packet8bf a,
const Packet8bf b,
const Packet8bf c 
)

Definition at line 1396 of file AltiVec/PacketMath.h.

◆ pmax() [1/2]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pmax ( const Packet a,
const Packet b 
)
inline

Definition at line 524 of file GenericPacketMath.h.

◆ pmax() [2/2]

template<int NaNPropagation, typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pmax ( const Packet a,
const Packet b 
)
inline

Definition at line 529 of file GenericPacketMath.h.

◆ pmax< Packet16bf >()

Definition at line 2103 of file AVX512/PacketMath.h.

◆ pmax< Packet16c >()

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::pmax< Packet16c > ( const Packet16c a,
const Packet16c b 
)

Definition at line 864 of file AltiVec/PacketMath.h.

◆ pmax< Packet16f >()

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pmax< Packet16f > ( const Packet16f a,
const Packet16f b 
)

Definition at line 384 of file AVX512/PacketMath.h.

◆ pmax< Packet16h >()

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::pmax< Packet16h > ( const Packet16h a,
const Packet16h b 
)

Definition at line 1502 of file AVX512/PacketMath.h.

◆ pmax< Packet16uc >()

Definition at line 865 of file AltiVec/PacketMath.h.

◆ pmax< Packet2d >()

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmax< Packet2d > ( const Packet2d a,
const Packet2d b 
)

Definition at line 989 of file MSA/PacketMath.h.

◆ pmax< Packet2f >()

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::pmax< Packet2f > ( const Packet2f a,
const Packet2f b 
)

Definition at line 1228 of file NEON/PacketMath.h.

◆ pmax< Packet2i >()

template<>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::pmax< Packet2i > ( const Packet2i a,
const Packet2i b 
)

Definition at line 1261 of file NEON/PacketMath.h.

◆ pmax< Packet2l >()

template<>
EIGEN_STRONG_INLINE Packet2l Eigen::internal::pmax< Packet2l > ( const Packet2l a,
const Packet2l b 
)

Definition at line 1265 of file NEON/PacketMath.h.

◆ pmax< Packet2ui >()

template<>
EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pmax< Packet2ui > ( const Packet2ui a,
const Packet2ui b 
)

Definition at line 1263 of file NEON/PacketMath.h.

◆ pmax< Packet2ul >()

template<>
EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pmax< Packet2ul > ( const Packet2ul a,
const Packet2ul b 
)

Definition at line 1270 of file NEON/PacketMath.h.

◆ pmax< Packet4bf >()

template<>
EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pmax< Packet4bf > ( const Packet4bf a,
const Packet4bf b 
)

Definition at line 3488 of file NEON/PacketMath.h.

◆ pmax< Packet4c >()

template<>
EIGEN_STRONG_INLINE Packet4c Eigen::internal::pmax< Packet4c > ( const Packet4c a,
const Packet4c b 
)

Definition at line 1241 of file NEON/PacketMath.h.

◆ pmax< Packet4d >()

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pmax< Packet4d > ( const Packet4d a,
const Packet4d b 
)

Definition at line 403 of file AVX/PacketMath.h.

◆ pmax< Packet4f >()

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmax< Packet4f > ( const Packet4f a,
const Packet4f b 
)

Definition at line 850 of file AltiVec/PacketMath.h.

◆ pmax< Packet4i >()

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmax< Packet4i > ( const Packet4i a,
const Packet4i b 
)

Definition at line 861 of file AltiVec/PacketMath.h.

◆ pmax< Packet4s >()

template<>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::pmax< Packet4s > ( const Packet4s a,
const Packet4s b 
)

Definition at line 1257 of file NEON/PacketMath.h.

◆ pmax< Packet4uc >()

template<>
EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pmax< Packet4uc > ( const Packet4uc a,
const Packet4uc b 
)

Definition at line 1249 of file NEON/PacketMath.h.

◆ pmax< Packet4ui >()

template<>
EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pmax< Packet4ui > ( const Packet4ui a,
const Packet4ui b 
)

Definition at line 1264 of file NEON/PacketMath.h.

◆ pmax< Packet4us >()

template<>
EIGEN_STRONG_INLINE Packet4us Eigen::internal::pmax< Packet4us > ( const Packet4us a,
const Packet4us b 
)

Definition at line 1259 of file NEON/PacketMath.h.

◆ pmax< Packet8bf >()

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pmax< Packet8bf > ( const Packet8bf a,
const Packet8bf b 
)

Definition at line 1412 of file AltiVec/PacketMath.h.

◆ pmax< Packet8c >()

template<>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::pmax< Packet8c > ( const Packet8c a,
const Packet8c b 
)

Definition at line 1247 of file NEON/PacketMath.h.

◆ pmax< Packet8d >()

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pmax< Packet8d > ( const Packet8d a,
const Packet8d b 
)

Definition at line 390 of file AVX512/PacketMath.h.

◆ pmax< Packet8f >()

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pmax< Packet8f > ( const Packet8f a,
const Packet8f b 
)

Definition at line 392 of file AVX/PacketMath.h.

◆ pmax< Packet8h >()

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::pmax< Packet8h > ( const Packet8h a,
const Packet8h b 
)

Definition at line 1032 of file AVX/PacketMath.h.

◆ pmax< Packet8s >()

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::pmax< Packet8s > ( const Packet8s a,
const Packet8s b 
)

Definition at line 862 of file AltiVec/PacketMath.h.

◆ pmax< Packet8uc >()

template<>
EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pmax< Packet8uc > ( const Packet8uc a,
const Packet8uc b 
)

Definition at line 1255 of file NEON/PacketMath.h.

◆ pmax< Packet8us >()

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::pmax< Packet8us > ( const Packet8us a,
const Packet8us b 
)

Definition at line 863 of file AltiVec/PacketMath.h.

◆ pmax< PacketXf >()

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

Definition at line 504 of file SVE/PacketMath.h.

◆ pmax< PacketXi >()

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

Definition at line 144 of file SVE/PacketMath.h.

◆ pmax< PropagateNaN, Packet16f >()

Definition at line 422 of file AVX512/PacketMath.h.

◆ pmax< PropagateNaN, Packet2d >()

Definition at line 593 of file SSE/PacketMath.h.

◆ pmax< PropagateNaN, Packet2f >()

Definition at line 1239 of file NEON/PacketMath.h.

◆ pmax< PropagateNaN, Packet4bf >()

Definition at line 3482 of file NEON/PacketMath.h.

◆ pmax< PropagateNaN, Packet4d >()

Definition at line 445 of file AVX/PacketMath.h.

◆ pmax< PropagateNaN, Packet4f >()

Definition at line 1237 of file NEON/PacketMath.h.

◆ pmax< PropagateNaN, Packet8d >()

Definition at line 426 of file AVX512/PacketMath.h.

◆ pmax< PropagateNaN, Packet8f >()

Definition at line 441 of file AVX/PacketMath.h.

◆ pmax< PropagateNaN, PacketXf >()

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::pmax< PropagateNaN, PacketXf > ( const PacketXf &  a,
const PacketXf &  b 
)

Definition at line 510 of file SVE/PacketMath.h.

◆ pmax< PropagateNumbers, Packet16f >()

Definition at line 406 of file AVX512/PacketMath.h.

◆ pmax< PropagateNumbers, Packet2d >()

Definition at line 577 of file SSE/PacketMath.h.

◆ pmax< PropagateNumbers, Packet4bf >()

Definition at line 3477 of file NEON/PacketMath.h.

◆ pmax< PropagateNumbers, Packet4d >()

Definition at line 429 of file AVX/PacketMath.h.

◆ pmax< PropagateNumbers, Packet4f >()

Definition at line 573 of file SSE/PacketMath.h.

◆ pmax< PropagateNumbers, Packet8d >()

Definition at line 410 of file AVX512/PacketMath.h.

◆ pmax< PropagateNumbers, Packet8f >()

Definition at line 425 of file AVX/PacketMath.h.

◆ pmax< PropagateNumbers, PacketXf >()

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::pmax< PropagateNumbers, PacketXf > ( const PacketXf &  a,
const PacketXf &  b 
)

Definition at line 516 of file SVE/PacketMath.h.

◆ pmin() [1/2]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pmin ( const Packet a,
const Packet b 
)
inline

Definition at line 512 of file GenericPacketMath.h.

◆ pmin() [2/2]

template<int NaNPropagation, typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pmin ( const Packet a,
const Packet b 
)
inline

Definition at line 517 of file GenericPacketMath.h.

◆ pmin< Packet16bf >()

Definition at line 2097 of file AVX512/PacketMath.h.

◆ pmin< Packet16c >()

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::pmin< Packet16c > ( const Packet16c a,
const Packet16c b 
)

Definition at line 846 of file AltiVec/PacketMath.h.

◆ pmin< Packet16f >()

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pmin< Packet16f > ( const Packet16f a,
const Packet16f b 
)

Definition at line 371 of file AVX512/PacketMath.h.

◆ pmin< Packet16h >()

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::pmin< Packet16h > ( const Packet16h a,
const Packet16h b 
)

Definition at line 1496 of file AVX512/PacketMath.h.

◆ pmin< Packet16uc >()

Definition at line 847 of file AltiVec/PacketMath.h.

◆ pmin< Packet2d >()

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmin< Packet2d > ( const Packet2d a,
const Packet2d b 
)

Definition at line 974 of file MSA/PacketMath.h.

◆ pmin< Packet2f >()

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::pmin< Packet2f > ( const Packet2f a,
const Packet2f b 
)

Definition at line 1180 of file NEON/PacketMath.h.

◆ pmin< Packet2i >()

template<>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::pmin< Packet2i > ( const Packet2i a,
const Packet2i b 
)

Definition at line 1213 of file NEON/PacketMath.h.

◆ pmin< Packet2l >()

template<>
EIGEN_STRONG_INLINE Packet2l Eigen::internal::pmin< Packet2l > ( const Packet2l a,
const Packet2l b 
)

Definition at line 1217 of file NEON/PacketMath.h.

◆ pmin< Packet2ui >()

template<>
EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pmin< Packet2ui > ( const Packet2ui a,
const Packet2ui b 
)

Definition at line 1215 of file NEON/PacketMath.h.

◆ pmin< Packet2ul >()

template<>
EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pmin< Packet2ul > ( const Packet2ul a,
const Packet2ul b 
)

Definition at line 1222 of file NEON/PacketMath.h.

◆ pmin< Packet4bf >()

template<>
EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pmin< Packet4bf > ( const Packet4bf a,
const Packet4bf b 
)

Definition at line 3471 of file NEON/PacketMath.h.

◆ pmin< Packet4c >()

template<>
EIGEN_STRONG_INLINE Packet4c Eigen::internal::pmin< Packet4c > ( const Packet4c a,
const Packet4c b 
)

Definition at line 1193 of file NEON/PacketMath.h.

◆ pmin< Packet4d >()

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pmin< Packet4d > ( const Packet4d a,
const Packet4d b 
)

Definition at line 380 of file AVX/PacketMath.h.

◆ pmin< Packet4f >()

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmin< Packet4f > ( const Packet4f a,
const Packet4f b 
)

Definition at line 832 of file AltiVec/PacketMath.h.

◆ pmin< Packet4i >()

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmin< Packet4i > ( const Packet4i a,
const Packet4i b 
)

Definition at line 843 of file AltiVec/PacketMath.h.

◆ pmin< Packet4s >()

template<>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::pmin< Packet4s > ( const Packet4s a,
const Packet4s b 
)

Definition at line 1209 of file NEON/PacketMath.h.

◆ pmin< Packet4uc >()

template<>
EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pmin< Packet4uc > ( const Packet4uc a,
const Packet4uc b 
)

Definition at line 1201 of file NEON/PacketMath.h.

◆ pmin< Packet4ui >()

template<>
EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pmin< Packet4ui > ( const Packet4ui a,
const Packet4ui b 
)

Definition at line 1216 of file NEON/PacketMath.h.

◆ pmin< Packet4us >()

template<>
EIGEN_STRONG_INLINE Packet4us Eigen::internal::pmin< Packet4us > ( const Packet4us a,
const Packet4us b 
)

Definition at line 1211 of file NEON/PacketMath.h.

◆ pmin< Packet8bf >()

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pmin< Packet8bf > ( const Packet8bf a,
const Packet8bf b 
)

Definition at line 1408 of file AltiVec/PacketMath.h.

◆ pmin< Packet8c >()

template<>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::pmin< Packet8c > ( const Packet8c a,
const Packet8c b 
)

Definition at line 1199 of file NEON/PacketMath.h.

◆ pmin< Packet8d >()

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pmin< Packet8d > ( const Packet8d a,
const Packet8d b 
)

Definition at line 377 of file AVX512/PacketMath.h.

◆ pmin< Packet8f >()

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pmin< Packet8f > ( const Packet8f a,
const Packet8f b 
)

Definition at line 366 of file AVX/PacketMath.h.

◆ pmin< Packet8h >()

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::pmin< Packet8h > ( const Packet8h a,
const Packet8h b 
)

Definition at line 1026 of file AVX/PacketMath.h.

◆ pmin< Packet8s >()

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::pmin< Packet8s > ( const Packet8s a,
const Packet8s b 
)

Definition at line 844 of file AltiVec/PacketMath.h.

◆ pmin< Packet8uc >()

template<>
EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pmin< Packet8uc > ( const Packet8uc a,
const Packet8uc b 
)

Definition at line 1207 of file NEON/PacketMath.h.

◆ pmin< Packet8us >()

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::pmin< Packet8us > ( const Packet8us a,
const Packet8us b 
)

Definition at line 845 of file AltiVec/PacketMath.h.

◆ pmin< PacketXf >()

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

Definition at line 486 of file SVE/PacketMath.h.

◆ pmin< PacketXi >()

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

Definition at line 138 of file SVE/PacketMath.h.

◆ pmin< PropagateNaN, Packet16f >()

Definition at line 414 of file AVX512/PacketMath.h.

◆ pmin< PropagateNaN, Packet2d >()

Definition at line 585 of file SSE/PacketMath.h.

◆ pmin< PropagateNaN, Packet2f >()

Definition at line 1191 of file NEON/PacketMath.h.

◆ pmin< PropagateNaN, Packet4bf >()

Definition at line 3465 of file NEON/PacketMath.h.

◆ pmin< PropagateNaN, Packet4d >()

Definition at line 437 of file AVX/PacketMath.h.

◆ pmin< PropagateNaN, Packet4f >()

Definition at line 1189 of file NEON/PacketMath.h.

◆ pmin< PropagateNaN, Packet8d >()

Definition at line 418 of file AVX512/PacketMath.h.

◆ pmin< PropagateNaN, Packet8f >()

Definition at line 433 of file AVX/PacketMath.h.

◆ pmin< PropagateNaN, PacketXf >()

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::pmin< PropagateNaN, PacketXf > ( const PacketXf &  a,
const PacketXf &  b 
)

Definition at line 492 of file SVE/PacketMath.h.

◆ pmin< PropagateNumbers, Packet16f >()

Definition at line 398 of file AVX512/PacketMath.h.

◆ pmin< PropagateNumbers, Packet2d >()

Definition at line 569 of file SSE/PacketMath.h.

◆ pmin< PropagateNumbers, Packet4bf >()

Definition at line 3460 of file NEON/PacketMath.h.

◆ pmin< PropagateNumbers, Packet4d >()

Definition at line 421 of file AVX/PacketMath.h.

◆ pmin< PropagateNumbers, Packet4f >()

Definition at line 565 of file SSE/PacketMath.h.

◆ pmin< PropagateNumbers, Packet8d >()

Definition at line 402 of file AVX512/PacketMath.h.

◆ pmin< PropagateNumbers, Packet8f >()

Definition at line 417 of file AVX/PacketMath.h.

◆ pmin< PropagateNumbers, PacketXf >()

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::pmin< PropagateNumbers, PacketXf > ( const PacketXf &  a,
const PacketXf &  b 
)

Definition at line 498 of file SVE/PacketMath.h.

◆ pminmax_propagate_nan()

template<typename Packet , typename Op >
EIGEN_STRONG_INLINE Packet Eigen::internal::pminmax_propagate_nan ( const Packet a,
const Packet b,
Op  op 
)

Definition at line 555 of file SSE/PacketMath.h.

◆ pminmax_propagate_numbers()

template<typename Packet , typename Op >
EIGEN_STRONG_INLINE Packet Eigen::internal::pminmax_propagate_numbers ( const Packet a,
const Packet b,
Op  op 
)

Definition at line 546 of file SSE/PacketMath.h.

◆ pmul() [1/4]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pmul ( const Packet a,
const Packet b 
)
inline

Definition at line 237 of file GenericPacketMath.h.

◆ pmul() [2/4]

template<>
EIGEN_DEVICE_FUNC bool Eigen::internal::pmul ( const bool &  a,
const bool &  b 
)
inline

Definition at line 240 of file GenericPacketMath.h.

◆ pmul() [3/4]

template<>
std::complex<float> Eigen::internal::pmul ( const std::complex< float > &  a,
const std::complex< float > &  b 
)
inline

Definition at line 1001 of file GenericPacketMath.h.

◆ pmul() [4/4]

template<>
std::complex<double> Eigen::internal::pmul ( const std::complex< double > &  a,
const std::complex< double > &  b 
)
inline

Definition at line 1004 of file GenericPacketMath.h.

◆ pmul< Packet16b >()

template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::pmul< Packet16b > ( const Packet16b a,
const Packet16b b 
)

Definition at line 364 of file SSE/PacketMath.h.

◆ pmul< Packet16bf >()

Definition at line 2085 of file AVX512/PacketMath.h.

◆ pmul< Packet16c >()

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::pmul< Packet16c > ( const Packet16c a,
const Packet16c b 
)

Definition at line 799 of file AltiVec/PacketMath.h.

◆ pmul< Packet16f >()

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pmul< Packet16f > ( const Packet16f a,
const Packet16f b 
)

Definition at line 313 of file AVX512/PacketMath.h.

◆ pmul< Packet16h >()

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::pmul< Packet16h > ( const Packet16h a,
const Packet16h b 
)

Definition at line 1586 of file AVX512/PacketMath.h.

◆ pmul< Packet16i >()

template<>
EIGEN_STRONG_INLINE Packet16i Eigen::internal::pmul< Packet16i > ( const Packet16i a,
const Packet16i b 
)

Definition at line 323 of file AVX512/PacketMath.h.

◆ pmul< Packet16uc >()

Definition at line 800 of file AltiVec/PacketMath.h.

◆ pmul< Packet1cd >()

template<>
EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pmul< Packet1cd > ( const Packet1cd a,
const Packet1cd b 
)

Definition at line 498 of file MSA/Complex.h.

◆ pmul< Packet1cf >()

template<>
EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pmul< Packet1cf > ( const Packet1cf a,
const Packet1cf b 
)

Definition at line 141 of file NEON/Complex.h.

◆ pmul< Packet2cd >()

template<>
EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pmul< Packet2cd > ( const Packet2cd a,
const Packet2cd b 
)

Definition at line 242 of file AVX/Complex.h.

◆ pmul< Packet2cf >()

template<>
EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pmul< Packet2cf > ( const Packet2cf a,
const Packet2cf b 
)

Definition at line 173 of file MSA/Complex.h.

◆ pmul< Packet2d >()

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmul< Packet2d > ( const Packet2d a,
const Packet2d b 
)

Definition at line 916 of file MSA/PacketMath.h.

◆ pmul< Packet2f >()

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::pmul< Packet2f > ( const Packet2f a,
const Packet2f b 
)

Definition at line 913 of file NEON/PacketMath.h.

◆ pmul< Packet2i >()

template<>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::pmul< Packet2i > ( const Packet2i a,
const Packet2i b 
)

Definition at line 935 of file NEON/PacketMath.h.

◆ pmul< Packet2l >()

template<>
EIGEN_STRONG_INLINE Packet2l Eigen::internal::pmul< Packet2l > ( const Packet2l a,
const Packet2l b 
)

Definition at line 939 of file NEON/PacketMath.h.

◆ pmul< Packet2ui >()

template<>
EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pmul< Packet2ui > ( const Packet2ui a,
const Packet2ui b 
)

Definition at line 937 of file NEON/PacketMath.h.

◆ pmul< Packet2ul >()

template<>
EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pmul< Packet2ul > ( const Packet2ul a,
const Packet2ul b 
)

Definition at line 944 of file NEON/PacketMath.h.

◆ pmul< Packet4bf >()

template<>
EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pmul< Packet4bf > ( const Packet4bf a,
const Packet4bf b 
)

Definition at line 3546 of file NEON/PacketMath.h.

◆ pmul< Packet4c >()

template<>
EIGEN_STRONG_INLINE Packet4c Eigen::internal::pmul< Packet4c > ( const Packet4c a,
const Packet4c b 
)

Definition at line 915 of file NEON/PacketMath.h.

◆ pmul< Packet4cd >()

template<>
EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pmul< Packet4cd > ( const Packet4cd a,
const Packet4cd b 
)

Definition at line 228 of file AVX512/Complex.h.

◆ pmul< Packet4cf >()

template<>
EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pmul< Packet4cf > ( const Packet4cf a,
const Packet4cf b 
)

Definition at line 76 of file AVX/Complex.h.

◆ pmul< Packet4d >()

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pmul< Packet4d > ( const Packet4d a,
const Packet4d b 
)

Definition at line 300 of file AVX/PacketMath.h.

◆ pmul< Packet4f >()

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmul< Packet4f > ( const Packet4f a,
const Packet4f b 
)

Definition at line 795 of file AltiVec/PacketMath.h.

◆ pmul< Packet4i >()

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmul< Packet4i > ( const Packet4i a,
const Packet4i b 
)

Definition at line 796 of file AltiVec/PacketMath.h.

◆ pmul< Packet4s >()

template<>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::pmul< Packet4s > ( const Packet4s a,
const Packet4s b 
)

Definition at line 931 of file NEON/PacketMath.h.

◆ pmul< Packet4uc >()

template<>
EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pmul< Packet4uc > ( const Packet4uc a,
const Packet4uc b 
)

Definition at line 923 of file NEON/PacketMath.h.

◆ pmul< Packet4ui >()

template<>
EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pmul< Packet4ui > ( const Packet4ui a,
const Packet4ui b 
)

Definition at line 938 of file NEON/PacketMath.h.

◆ pmul< Packet4us >()

template<>
EIGEN_STRONG_INLINE Packet4us Eigen::internal::pmul< Packet4us > ( const Packet4us a,
const Packet4us b 
)

Definition at line 933 of file NEON/PacketMath.h.

◆ pmul< Packet8bf >()

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pmul< Packet8bf > ( const Packet8bf a,
const Packet8bf b 
)

Definition at line 1328 of file AltiVec/PacketMath.h.

◆ pmul< Packet8c >()

template<>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::pmul< Packet8c > ( const Packet8c a,
const Packet8c b 
)

Definition at line 921 of file NEON/PacketMath.h.

◆ pmul< Packet8cf >()

template<>
EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pmul< Packet8cf > ( const Packet8cf a,
const Packet8cf b 
)

Definition at line 77 of file AVX512/Complex.h.

◆ pmul< Packet8d >()

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pmul< Packet8d > ( const Packet8d a,
const Packet8d b 
)

Definition at line 318 of file AVX512/PacketMath.h.

◆ pmul< Packet8f >()

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pmul< Packet8f > ( const Packet8f a,
const Packet8f b 
)

Definition at line 299 of file AVX/PacketMath.h.

◆ pmul< Packet8h >()

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::pmul< Packet8h > ( const Packet8h a,
const Packet8h b 
)

Definition at line 1114 of file AVX/PacketMath.h.

◆ pmul< Packet8i >()

template<>
EIGEN_STRONG_INLINE Packet8i Eigen::internal::pmul< Packet8i > ( const Packet8i a,
const Packet8i b 
)

Definition at line 301 of file AVX/PacketMath.h.

◆ pmul< Packet8s >()

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::pmul< Packet8s > ( const Packet8s a,
const Packet8s b 
)

Definition at line 797 of file AltiVec/PacketMath.h.

◆ pmul< Packet8uc >()

template<>
EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pmul< Packet8uc > ( const Packet8uc a,
const Packet8uc b 
)

Definition at line 929 of file NEON/PacketMath.h.

◆ pmul< Packet8us >()

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::pmul< Packet8us > ( const Packet8us a,
const Packet8us b 
)

Definition at line 798 of file AltiVec/PacketMath.h.

◆ pmul< PacketXf >()

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

Definition at line 468 of file SVE/PacketMath.h.

◆ pmul< PacketXi >()

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

Definition at line 120 of file SVE/PacketMath.h.

◆ pndtri()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pndtri ( const Packet a)

Definition at line 43 of file SpecialFunctionsPacketMath.h.

◆ pnegate() [1/31]

template<>
EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pnegate ( const Packet8cf a)

Definition at line 65 of file AVX512/Complex.h.

◆ pnegate() [2/31]

template<>
EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pnegate ( const Packet4cf a)

Definition at line 66 of file AVX/Complex.h.

◆ pnegate() [3/31]

template<>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::pnegate ( const PacketXi &  a)

Definition at line 108 of file SVE/PacketMath.h.

◆ pnegate() [4/31]

template<>
EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pnegate ( const Packet1cf a)

Definition at line 127 of file NEON/Complex.h.

◆ pnegate() [5/31]

template<>
EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pnegate ( const Packet2cf a)

Definition at line 166 of file AltiVec/Complex.h.

◆ pnegate() [6/31]

template<>
EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pnegate ( const Packet4cd a)

Definition at line 219 of file AVX512/Complex.h.

◆ pnegate() [7/31]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pnegate ( const Packet a)
inline

Definition at line 226 of file GenericPacketMath.h.

◆ pnegate() [8/31]

template<>
EIGEN_DEVICE_FUNC bool Eigen::internal::pnegate ( const bool &  a)
inline

Definition at line 229 of file GenericPacketMath.h.

◆ pnegate() [9/31]

template<>
EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pnegate ( const Packet2cd a)

Definition at line 235 of file AVX/Complex.h.

◆ pnegate() [10/31]

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pnegate ( const Packet8f a)

Definition at line 286 of file AVX/PacketMath.h.

◆ pnegate() [11/31]

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pnegate ( const Packet4d a)

Definition at line 290 of file AVX/PacketMath.h.

◆ pnegate() [12/31]

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pnegate ( const Packet16f a)

Definition at line 291 of file AVX512/PacketMath.h.

◆ pnegate() [13/31]

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pnegate ( const Packet8d a)

Definition at line 295 of file AVX512/PacketMath.h.

◆ pnegate() [14/31]

template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::pnegate ( const Packet16b a)

Definition at line 337 of file SSE/PacketMath.h.

◆ pnegate() [15/31]

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::pnegate ( const PacketXf &  a)

Definition at line 456 of file SVE/PacketMath.h.

◆ pnegate() [16/31]

template<>
EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pnegate ( const Packet1cd a)

Definition at line 484 of file MSA/Complex.h.

◆ pnegate() [17/31]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pnegate ( const Packet4f a)

Definition at line 789 of file AltiVec/PacketMath.h.

◆ pnegate() [18/31]

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pnegate ( const Packet4i a)

Definition at line 790 of file AltiVec/PacketMath.h.

◆ pnegate() [19/31]

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::pnegate ( const Packet2f a)

Definition at line 874 of file NEON/PacketMath.h.

◆ pnegate() [20/31]

template<>
EIGEN_STRONG_INLINE Packet4c Eigen::internal::pnegate ( const Packet4c a)

Definition at line 876 of file NEON/PacketMath.h.

◆ pnegate() [21/31]

template<>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::pnegate ( const Packet8c a)

Definition at line 878 of file NEON/PacketMath.h.

◆ pnegate() [22/31]

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::pnegate ( const Packet16c a)

Definition at line 879 of file NEON/PacketMath.h.

◆ pnegate() [23/31]

template<>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::pnegate ( const Packet4s a)

Definition at line 880 of file NEON/PacketMath.h.

◆ pnegate() [24/31]

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::pnegate ( const Packet8s a)

Definition at line 881 of file NEON/PacketMath.h.

◆ pnegate() [25/31]

template<>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::pnegate ( const Packet2i a)

Definition at line 882 of file NEON/PacketMath.h.

◆ pnegate() [26/31]

template<>
EIGEN_STRONG_INLINE Packet2l Eigen::internal::pnegate ( const Packet2l a)

Definition at line 884 of file NEON/PacketMath.h.

◆ pnegate() [27/31]

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pnegate ( const Packet2d a)

Definition at line 902 of file MSA/PacketMath.h.

◆ pnegate() [28/31]

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::pnegate ( const Packet8h a)

Definition at line 1095 of file AVX/PacketMath.h.

◆ pnegate() [29/31]

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pnegate ( const Packet8bf a)

Definition at line 1442 of file AVX/PacketMath.h.

◆ pnegate() [30/31]

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::pnegate ( const Packet16h a)

Definition at line 1567 of file AVX512/PacketMath.h.

◆ pnegate() [31/31]

template<>
EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pnegate ( const Packet16bf a)

Definition at line 2056 of file AVX512/PacketMath.h.

◆ pnegate< Packet4bf >()

Definition at line 3621 of file NEON/PacketMath.h.

◆ pnegate< Packet8bf >()

Definition at line 1336 of file AltiVec/PacketMath.h.

◆ pnot()

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pnot ( const Packet a)
inline

Definition at line 425 of file GenericPacketMath.h.

◆ por() [1/6]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::por ( const Packet a,
const Packet b 
)
inline

Definition at line 413 of file GenericPacketMath.h.

◆ por() [2/6]

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::por ( const Packet8h a,
const Packet8h b 
)

Definition at line 1042 of file AVX/PacketMath.h.

◆ por() [3/6]

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::por ( const Packet8bf a,
const Packet8bf b 
)

Definition at line 1390 of file AVX/PacketMath.h.

◆ por() [4/6]

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::por ( const Packet16h a,
const Packet16h b 
)

Definition at line 1512 of file AVX512/PacketMath.h.

◆ por() [5/6]

template<>
EIGEN_STRONG_INLINE Packet16bf Eigen::internal::por ( const Packet16bf a,
const Packet16bf b 
)

Definition at line 1985 of file AVX512/PacketMath.h.

◆ por() [6/6]

template<>
EIGEN_STRONG_INLINE Packet4bf Eigen::internal::por ( const Packet4bf a,
const Packet4bf b 
)

Definition at line 3499 of file NEON/PacketMath.h.

◆ por< Packet16b >()

template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::por< Packet16b > ( const Packet16b a,
const Packet16b b 
)

Definition at line 420 of file SSE/PacketMath.h.

◆ por< Packet16c >()

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::por< Packet16c > ( const Packet16c a,
const Packet16c b 
)

Definition at line 1504 of file NEON/PacketMath.h.

◆ por< Packet16f >()

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::por< Packet16f > ( const Packet16f a,
const Packet16f b 
)

Definition at line 588 of file AVX512/PacketMath.h.

◆ por< Packet16i >()

template<>
EIGEN_STRONG_INLINE Packet16i Eigen::internal::por< Packet16i > ( const Packet16i a,
const Packet16i b 
)

Definition at line 583 of file AVX512/PacketMath.h.

◆ por< Packet16uc >()

Definition at line 1510 of file NEON/PacketMath.h.

◆ por< Packet1cd >()

template<>
EIGEN_STRONG_INLINE Packet1cd Eigen::internal::por< Packet1cd > ( const Packet1cd a,
const Packet1cd b 
)

Definition at line 512 of file MSA/Complex.h.

◆ por< Packet1cf >()

template<>
EIGEN_STRONG_INLINE Packet1cf Eigen::internal::por< Packet1cf > ( const Packet1cf a,
const Packet1cf b 
)

Definition at line 208 of file NEON/Complex.h.

◆ por< Packet2cd >()

template<>
EIGEN_STRONG_INLINE Packet2cd Eigen::internal::por< Packet2cd > ( const Packet2cd a,
const Packet2cd b 
)

Definition at line 260 of file AVX/Complex.h.

◆ por< Packet2cf >()

template<>
EIGEN_STRONG_INLINE Packet2cf Eigen::internal::por< Packet2cf > ( const Packet2cf a,
const Packet2cf b 
)

Definition at line 170 of file AltiVec/Complex.h.

◆ por< Packet2d >()

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::por< Packet2d > ( const Packet2d a,
const Packet2d b 
)

Definition at line 946 of file MSA/PacketMath.h.

◆ por< Packet2f >()

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::por< Packet2f > ( const Packet2f a,
const Packet2f b 
)

Definition at line 1497 of file NEON/PacketMath.h.

◆ por< Packet2i >()

template<>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::por< Packet2i > ( const Packet2i a,
const Packet2i b 
)

Definition at line 1520 of file NEON/PacketMath.h.

◆ por< Packet2l >()

template<>
EIGEN_STRONG_INLINE Packet2l Eigen::internal::por< Packet2l > ( const Packet2l a,
const Packet2l b 
)

Definition at line 1526 of file NEON/PacketMath.h.

◆ por< Packet2ui >()

template<>
EIGEN_STRONG_INLINE Packet2ui Eigen::internal::por< Packet2ui > ( const Packet2ui a,
const Packet2ui b 
)

Definition at line 1522 of file NEON/PacketMath.h.

◆ por< Packet2ul >()

template<>
EIGEN_STRONG_INLINE Packet2ul Eigen::internal::por< Packet2ul > ( const Packet2ul a,
const Packet2ul b 
)

Definition at line 1528 of file NEON/PacketMath.h.

◆ por< Packet4c >()

template<>
EIGEN_STRONG_INLINE Packet4c Eigen::internal::por< Packet4c > ( const Packet4c a,
const Packet4c b 
)

Definition at line 1501 of file NEON/PacketMath.h.

◆ por< Packet4cd >()

template<>
EIGEN_STRONG_INLINE Packet4cd Eigen::internal::por< Packet4cd > ( const Packet4cd a,
const Packet4cd b 
)

Definition at line 239 of file AVX512/Complex.h.

◆ por< Packet4cf >()

template<>
EIGEN_STRONG_INLINE Packet4cf Eigen::internal::por< Packet4cf > ( const Packet4cf a,
const Packet4cf b 
)

Definition at line 92 of file AVX/Complex.h.

◆ por< Packet4d >()

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::por< Packet4d > ( const Packet4d a,
const Packet4d b 
)

Definition at line 500 of file AVX/PacketMath.h.

◆ por< Packet4f >()

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::por< Packet4f > ( const Packet4f a,
const Packet4f b 
)

Definition at line 900 of file AltiVec/PacketMath.h.

◆ por< Packet4i >()

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::por< Packet4i > ( const Packet4i a,
const Packet4i b 
)

Definition at line 901 of file AltiVec/PacketMath.h.

◆ por< Packet4s >()

template<>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::por< Packet4s > ( const Packet4s a,
const Packet4s b 
)

Definition at line 1512 of file NEON/PacketMath.h.

◆ por< Packet4uc >()

template<>
EIGEN_STRONG_INLINE Packet4uc Eigen::internal::por< Packet4uc > ( const Packet4uc a,
const Packet4uc b 
)

Definition at line 1506 of file NEON/PacketMath.h.

◆ por< Packet4ui >()

template<>
EIGEN_STRONG_INLINE Packet4ui Eigen::internal::por< Packet4ui > ( const Packet4ui a,
const Packet4ui b 
)

Definition at line 1524 of file NEON/PacketMath.h.

◆ por< Packet4us >()

template<>
EIGEN_STRONG_INLINE Packet4us Eigen::internal::por< Packet4us > ( const Packet4us a,
const Packet4us b 
)

Definition at line 1516 of file NEON/PacketMath.h.

◆ por< Packet8bf >()

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::por< Packet8bf > ( const Packet8bf a,
const Packet8bf b 
)

Definition at line 904 of file AltiVec/PacketMath.h.

◆ por< Packet8c >()

template<>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::por< Packet8c > ( const Packet8c a,
const Packet8c b 
)

Definition at line 1503 of file NEON/PacketMath.h.

◆ por< Packet8cf >()

template<>
EIGEN_STRONG_INLINE Packet8cf Eigen::internal::por< Packet8cf > ( const Packet8cf a,
const Packet8cf b 
)

Definition at line 84 of file AVX512/Complex.h.

◆ por< Packet8d >()

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::por< Packet8d > ( const Packet8d a,
const Packet8d b 
)

Definition at line 597 of file AVX512/PacketMath.h.

◆ por< Packet8f >()

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::por< Packet8f > ( const Packet8f a,
const Packet8f b 
)

Definition at line 499 of file AVX/PacketMath.h.

◆ por< Packet8i >()

template<>
EIGEN_STRONG_INLINE Packet8i Eigen::internal::por< Packet8i > ( const Packet8i a,
const Packet8i b 
)

Definition at line 501 of file AVX/PacketMath.h.

◆ por< Packet8s >()

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::por< Packet8s > ( const Packet8s a,
const Packet8s b 
)

Definition at line 902 of file AltiVec/PacketMath.h.

◆ por< Packet8uc >()

template<>
EIGEN_STRONG_INLINE Packet8uc Eigen::internal::por< Packet8uc > ( const Packet8uc a,
const Packet8uc b 
)

Definition at line 1508 of file NEON/PacketMath.h.

◆ por< Packet8us >()

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::por< Packet8us > ( const Packet8us a,
const Packet8us b 
)

Definition at line 903 of file AltiVec/PacketMath.h.

◆ por< PacketXf >()

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

Definition at line 570 of file SVE/PacketMath.h.

◆ por< PacketXi >()

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

Definition at line 186 of file SVE/PacketMath.h.

◆ positive_real_hypot()

template<typename RealScalar >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE RealScalar Eigen::internal::positive_real_hypot ( const RealScalar x,
const RealScalar y 
)

Definition at line 80 of file MathFunctionsImpl.h.

◆ ppolygamma()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::ppolygamma ( const Packet n,
const Packet x 
)

Definition at line 31 of file SpecialFunctionsPacketMath.h.

◆ predux()

template<typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits<Packet>::type Eigen::internal::predux ( const Packet a)
inline

Definition at line 875 of file GenericPacketMath.h.

◆ predux< Packet16b >()

Definition at line 1026 of file SSE/PacketMath.h.

◆ predux< Packet16bf >()

Definition at line 2121 of file AVX512/PacketMath.h.

◆ predux< Packet16c >() [1/2]

template<>
EIGEN_STRONG_INLINE signed char Eigen::internal::predux< Packet16c > ( const Packet16c a)

Definition at line 1521 of file AltiVec/PacketMath.h.

◆ predux< Packet16c >() [2/2]

Definition at line 2407 of file NEON/PacketMath.h.

◆ predux< Packet16f >()

template<>
EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet16f > ( const Packet16f a)

Definition at line 978 of file AVX512/PacketMath.h.

◆ predux< Packet16h >()

Definition at line 1600 of file AVX512/PacketMath.h.

◆ predux< Packet16uc >() [1/2]

template<>
EIGEN_STRONG_INLINE unsigned char Eigen::internal::predux< Packet16uc > ( const Packet16uc a)

Definition at line 1526 of file AltiVec/PacketMath.h.

◆ predux< Packet16uc >() [2/2]

Definition at line 2429 of file NEON/PacketMath.h.

◆ predux< Packet1cd >()

template<>
EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux< Packet1cd > ( const Packet1cd a)

Definition at line 598 of file MSA/Complex.h.

◆ predux< Packet1cf >()

template<>
EIGEN_STRONG_INLINE std::complex<float> Eigen::internal::predux< Packet1cf > ( const Packet1cf a)

Definition at line 299 of file NEON/Complex.h.

◆ predux< Packet2cd >()

template<>
EIGEN_STRONG_INLINE std::complex<double> Eigen::internal::predux< Packet2cd > ( const Packet2cd a)

Definition at line 308 of file AVX/Complex.h.

◆ predux< Packet2cf >()

template<>
EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux< Packet2cf > ( const Packet2cf a)

Definition at line 191 of file AltiVec/Complex.h.

◆ predux< Packet2d >()

template<>
EIGEN_STRONG_INLINE double Eigen::internal::predux< Packet2d > ( const Packet2d a)

Definition at line 1082 of file MSA/PacketMath.h.

◆ predux< Packet2f >()

template<>
EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet2f > ( const Packet2f a)

Definition at line 2387 of file NEON/PacketMath.h.

◆ predux< Packet2i >()

Definition at line 2461 of file NEON/PacketMath.h.

◆ predux< Packet2l >()

Definition at line 2473 of file NEON/PacketMath.h.

◆ predux< Packet2ui >()

Definition at line 2467 of file NEON/PacketMath.h.

◆ predux< Packet2ul >()

Definition at line 2475 of file NEON/PacketMath.h.

◆ predux< Packet4bf >()

Definition at line 3566 of file NEON/PacketMath.h.

◆ predux< Packet4c >()

Definition at line 2393 of file NEON/PacketMath.h.

◆ predux< Packet4cd >()

template<>
EIGEN_STRONG_INLINE std::complex<double> Eigen::internal::predux< Packet4cd > ( const Packet4cd a)

Definition at line 300 of file AVX512/Complex.h.

◆ predux< Packet4cf >()

template<>
EIGEN_STRONG_INLINE std::complex<float> Eigen::internal::predux< Packet4cf > ( const Packet4cf a)

Definition at line 158 of file AVX/Complex.h.

◆ predux< Packet4d >()

template<>
EIGEN_STRONG_INLINE double Eigen::internal::predux< Packet4d > ( const Packet4d a)

Definition at line 802 of file AVX/PacketMath.h.

◆ predux< Packet4f >()

template<>
EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet4f > ( const Packet4f a)

Definition at line 1444 of file AltiVec/PacketMath.h.

◆ predux< Packet4i >() [1/2]

Definition at line 576 of file MSA/PacketMath.h.

◆ predux< Packet4i >() [2/2]

Definition at line 1454 of file AltiVec/PacketMath.h.

◆ predux< Packet4s >()

Definition at line 2437 of file NEON/PacketMath.h.

◆ predux< Packet4uc >()

Definition at line 2415 of file NEON/PacketMath.h.

◆ predux< Packet4ui >()

Definition at line 2468 of file NEON/PacketMath.h.

◆ predux< Packet4us >()

Definition at line 2449 of file NEON/PacketMath.h.

◆ predux< Packet8bf >()

Definition at line 1466 of file AltiVec/PacketMath.h.

◆ predux< Packet8c >()

Definition at line 2400 of file NEON/PacketMath.h.

◆ predux< Packet8cf >()

template<>
EIGEN_STRONG_INLINE std::complex<float> Eigen::internal::predux< Packet8cf > ( const Packet8cf a)

Definition at line 136 of file AVX512/Complex.h.

◆ predux< Packet8d >()

template<>
EIGEN_STRONG_INLINE double Eigen::internal::predux< Packet8d > ( const Packet8d a)

Definition at line 996 of file AVX512/PacketMath.h.

◆ predux< Packet8f >()

template<>
EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet8f > ( const Packet8f a)

Definition at line 798 of file AVX/PacketMath.h.

◆ predux< Packet8h >()

Definition at line 1155 of file AVX/PacketMath.h.

◆ predux< Packet8s >() [1/2]

template<>
EIGEN_STRONG_INLINE short int Eigen::internal::predux< Packet8s > ( const Packet8s a)

Definition at line 1489 of file AltiVec/PacketMath.h.

◆ predux< Packet8s >() [2/2]

Definition at line 2442 of file NEON/PacketMath.h.

◆ predux< Packet8uc >()

Definition at line 2422 of file NEON/PacketMath.h.

◆ predux< Packet8us >() [1/2]

template<>
EIGEN_STRONG_INLINE unsigned short int Eigen::internal::predux< Packet8us > ( const Packet8us a)

Definition at line 1494 of file AltiVec/PacketMath.h.

◆ predux< Packet8us >() [2/2]

Definition at line 2454 of file NEON/PacketMath.h.

◆ predux< PacketXf >()

template<>
EIGEN_STRONG_INLINE float Eigen::internal::predux< PacketXf > ( const PacketXf &  a)

Definition at line 672 of file SVE/PacketMath.h.

◆ predux< PacketXi >()

template<>
EIGEN_STRONG_INLINE numext::int32_t Eigen::internal::predux< PacketXi > ( const PacketXi &  a)

Definition at line 298 of file SVE/PacketMath.h.

◆ predux_any() [1/4]

template<>
EIGEN_STRONG_INLINE bool Eigen::internal::predux_any ( const Packet8f x)

Definition at line 857 of file AVX/PacketMath.h.

◆ predux_any() [2/4]

template<typename Packet >
EIGEN_DEVICE_FUNC bool Eigen::internal::predux_any ( const Packet a)
inline

Definition at line 930 of file GenericPacketMath.h.

◆ predux_any() [3/4]

template<>
EIGEN_STRONG_INLINE bool Eigen::internal::predux_any ( const Packet16f x)

Definition at line 1095 of file AVX512/PacketMath.h.

◆ predux_any() [4/4]

template<>
EIGEN_STRONG_INLINE bool Eigen::internal::predux_any ( const Packet4f x)

Definition at line 1765 of file AltiVec/PacketMath.h.

◆ predux_half_dowto4() [1/9]

template<typename Packet >
const DoublePacket<Packet>& Eigen::internal::predux_half_dowto4 ( const DoublePacket< Packet > &  a)

Definition at line 703 of file products/GeneralBlockPanelKernel.h.

◆ predux_half_dowto4() [2/9]

template<typename Packet >
DoublePacket<typename unpacket_traits<Packet>::half> Eigen::internal::predux_half_dowto4 ( const DoublePacket< Packet > &  a,
typename enable_if< unpacket_traits< Packet >::size==16 >::type = 0 
)

Definition at line 711 of file products/GeneralBlockPanelKernel.h.

◆ predux_half_dowto4() [3/9]

template<typename Packet >
EIGEN_DEVICE_FUNC conditional<(unpacket_traits<Packet>::size%8)==0,typename unpacket_traits<Packet>::half,Packet>::type Eigen::internal::predux_half_dowto4 ( const Packet a)
inline

Definition at line 853 of file GenericPacketMath.h.

◆ predux_half_dowto4() [4/9]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4c Eigen::internal::predux_half_dowto4 ( const Packet8c a)

Definition at line 2478 of file NEON/PacketMath.h.

◆ predux_half_dowto4() [5/9]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c Eigen::internal::predux_half_dowto4 ( const Packet16c a)

Definition at line 2483 of file NEON/PacketMath.h.

◆ predux_half_dowto4() [6/9]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4uc Eigen::internal::predux_half_dowto4 ( const Packet8uc a)

Definition at line 2485 of file NEON/PacketMath.h.

◆ predux_half_dowto4() [7/9]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc Eigen::internal::predux_half_dowto4 ( const Packet16uc a)

Definition at line 2490 of file NEON/PacketMath.h.

◆ predux_half_dowto4() [8/9]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s Eigen::internal::predux_half_dowto4 ( const Packet8s a)

Definition at line 2492 of file NEON/PacketMath.h.

◆ predux_half_dowto4() [9/9]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us Eigen::internal::predux_half_dowto4 ( const Packet8us a)

Definition at line 2494 of file NEON/PacketMath.h.

◆ predux_half_dowto4< Packet16bf >()

Definition at line 2114 of file AVX512/PacketMath.h.

◆ predux_half_dowto4< Packet16f >()

Definition at line 1005 of file AVX512/PacketMath.h.

◆ predux_half_dowto4< Packet16h >()

Definition at line 1606 of file AVX512/PacketMath.h.

◆ predux_half_dowto4< Packet8cf >()

Definition at line 149 of file AVX512/Complex.h.

◆ predux_half_dowto4< Packet8d >()

Definition at line 1021 of file AVX512/PacketMath.h.

◆ predux_half_dowto4< Packet8f >()

Definition at line 807 of file AVX/PacketMath.h.

◆ predux_helper()

template<typename Packet , typename Op >
EIGEN_DEVICE_FUNC unpacket_traits<Packet>::type Eigen::internal::predux_helper ( const Packet a,
Op  op 
)
inline

Definition at line 859 of file GenericPacketMath.h.

◆ predux_max() [1/2]

template<typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits<Packet>::type Eigen::internal::predux_max ( const Packet a)
inline

Definition at line 905 of file GenericPacketMath.h.

◆ predux_max() [2/2]

template<int NaNPropagation, typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits<Packet>::type Eigen::internal::predux_max ( const Packet a)
inline

Definition at line 912 of file GenericPacketMath.h.

◆ predux_max< Packet16bf >()

Definition at line 2136 of file AVX512/PacketMath.h.

◆ predux_max< Packet16c >() [1/2]

template<>
EIGEN_STRONG_INLINE signed char Eigen::internal::predux_max< Packet16c > ( const Packet16c a)

Definition at line 1741 of file AltiVec/PacketMath.h.

◆ predux_max< Packet16c >() [2/2]

Definition at line 2693 of file NEON/PacketMath.h.

◆ predux_max< Packet16f >()

Definition at line 1076 of file AVX512/PacketMath.h.

◆ predux_max< Packet16h >()

Definition at line 1612 of file AVX512/PacketMath.h.

◆ predux_max< Packet16uc >() [1/2]

template<>
EIGEN_STRONG_INLINE unsigned char Eigen::internal::predux_max< Packet16uc > ( const Packet16uc a)

Definition at line 1753 of file AltiVec/PacketMath.h.

◆ predux_max< Packet16uc >() [2/2]

Definition at line 2715 of file NEON/PacketMath.h.

◆ predux_max< Packet2d >()

Definition at line 1116 of file MSA/PacketMath.h.

◆ predux_max< Packet2f >()

Definition at line 2672 of file NEON/PacketMath.h.

◆ predux_max< Packet2i >()

Definition at line 2747 of file NEON/PacketMath.h.

◆ predux_max< Packet2l >()

Definition at line 2761 of file NEON/PacketMath.h.

◆ predux_max< Packet2ui >()

Definition at line 2754 of file NEON/PacketMath.h.

◆ predux_max< Packet2ul >()

Definition at line 2763 of file NEON/PacketMath.h.

◆ predux_max< Packet4bf >()

Definition at line 3571 of file NEON/PacketMath.h.

◆ predux_max< Packet4c >()

Definition at line 2679 of file NEON/PacketMath.h.

◆ predux_max< Packet4d >()

Definition at line 845 of file AVX/PacketMath.h.

◆ predux_max< Packet4f >()

Definition at line 1693 of file AltiVec/PacketMath.h.

◆ predux_max< Packet4i >() [1/2]

Definition at line 666 of file MSA/PacketMath.h.

◆ predux_max< Packet4i >() [2/2]

Definition at line 1698 of file AltiVec/PacketMath.h.

◆ predux_max< Packet4s >()

Definition at line 2723 of file NEON/PacketMath.h.

◆ predux_max< Packet4uc >()

Definition at line 2701 of file NEON/PacketMath.h.

◆ predux_max< Packet4ui >()

Definition at line 2756 of file NEON/PacketMath.h.

◆ predux_max< Packet4us >()

Definition at line 2735 of file NEON/PacketMath.h.

◆ predux_max< Packet8bf >()

Definition at line 1703 of file AltiVec/PacketMath.h.

◆ predux_max< Packet8c >()

Definition at line 2686 of file NEON/PacketMath.h.

◆ predux_max< Packet8d >()

Definition at line 1087 of file AVX512/PacketMath.h.

◆ predux_max< Packet8f >()

Definition at line 838 of file AVX/PacketMath.h.

◆ predux_max< Packet8h >()

Definition at line 1161 of file AVX/PacketMath.h.

◆ predux_max< Packet8s >() [1/2]

Definition at line 1711 of file AltiVec/PacketMath.h.

◆ predux_max< Packet8s >() [2/2]

Definition at line 2728 of file NEON/PacketMath.h.

◆ predux_max< Packet8uc >()

Definition at line 2708 of file NEON/PacketMath.h.

◆ predux_max< Packet8us >() [1/2]

template<>
EIGEN_STRONG_INLINE unsigned short int Eigen::internal::predux_max< Packet8us > ( const Packet8us a)

Definition at line 1726 of file AltiVec/PacketMath.h.

◆ predux_max< Packet8us >() [2/2]

Definition at line 2740 of file NEON/PacketMath.h.

◆ predux_max< PacketXf >()

template<>
EIGEN_STRONG_INLINE float Eigen::internal::predux_max< PacketXf > ( const PacketXf &  a)

Definition at line 721 of file SVE/PacketMath.h.

◆ predux_max< PacketXi >()

template<>
EIGEN_STRONG_INLINE numext::int32_t Eigen::internal::predux_max< PacketXi > ( const PacketXi &  a)

Definition at line 345 of file SVE/PacketMath.h.

◆ predux_min() [1/2]

template<typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits<Packet>::type Eigen::internal::predux_min ( const Packet a)
inline

Definition at line 890 of file GenericPacketMath.h.

◆ predux_min() [2/2]

template<int NaNPropagation, typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits<Packet>::type Eigen::internal::predux_min ( const Packet a)
inline

Definition at line 897 of file GenericPacketMath.h.

◆ predux_min< Packet16bf >()

Definition at line 2131 of file AVX512/PacketMath.h.

◆ predux_min< Packet16c >() [1/2]

template<>
EIGEN_STRONG_INLINE signed char Eigen::internal::predux_min< Packet16c > ( const Packet16c a)

Definition at line 1661 of file AltiVec/PacketMath.h.

◆ predux_min< Packet16c >() [2/2]

Definition at line 2598 of file NEON/PacketMath.h.

◆ predux_min< Packet16f >()

Definition at line 1057 of file AVX512/PacketMath.h.

◆ predux_min< Packet16h >()

Definition at line 1618 of file AVX512/PacketMath.h.

◆ predux_min< Packet16uc >() [1/2]

template<>
EIGEN_STRONG_INLINE unsigned char Eigen::internal::predux_min< Packet16uc > ( const Packet16uc a)

Definition at line 1673 of file AltiVec/PacketMath.h.

◆ predux_min< Packet16uc >() [2/2]

Definition at line 2620 of file NEON/PacketMath.h.

◆ predux_min< Packet2d >()

Definition at line 1101 of file MSA/PacketMath.h.

◆ predux_min< Packet2f >()

Definition at line 2577 of file NEON/PacketMath.h.

◆ predux_min< Packet2i >()

Definition at line 2652 of file NEON/PacketMath.h.

◆ predux_min< Packet2l >()

Definition at line 2666 of file NEON/PacketMath.h.

◆ predux_min< Packet2ui >()

Definition at line 2659 of file NEON/PacketMath.h.

◆ predux_min< Packet2ul >()

Definition at line 2668 of file NEON/PacketMath.h.

◆ predux_min< Packet4bf >()

Definition at line 3576 of file NEON/PacketMath.h.

◆ predux_min< Packet4c >()

Definition at line 2584 of file NEON/PacketMath.h.

◆ predux_min< Packet4d >()

Definition at line 832 of file AVX/PacketMath.h.

◆ predux_min< Packet4f >()

Definition at line 1613 of file AltiVec/PacketMath.h.

◆ predux_min< Packet4i >() [1/2]

Definition at line 631 of file MSA/PacketMath.h.

◆ predux_min< Packet4i >() [2/2]

Definition at line 1618 of file AltiVec/PacketMath.h.

◆ predux_min< Packet4s >()

Definition at line 2628 of file NEON/PacketMath.h.

◆ predux_min< Packet4uc >()

Definition at line 2606 of file NEON/PacketMath.h.

◆ predux_min< Packet4ui >()

Definition at line 2661 of file NEON/PacketMath.h.

◆ predux_min< Packet4us >()

Definition at line 2640 of file NEON/PacketMath.h.

◆ predux_min< Packet8bf >()

Definition at line 1623 of file AltiVec/PacketMath.h.

◆ predux_min< Packet8c >()

Definition at line 2591 of file NEON/PacketMath.h.

◆ predux_min< Packet8d >()

Definition at line 1067 of file AVX512/PacketMath.h.

◆ predux_min< Packet8f >()

Definition at line 826 of file AVX/PacketMath.h.

◆ predux_min< Packet8h >()

Definition at line 1167 of file AVX/PacketMath.h.

◆ predux_min< Packet8s >() [1/2]

Definition at line 1631 of file AltiVec/PacketMath.h.

◆ predux_min< Packet8s >() [2/2]

Definition at line 2633 of file NEON/PacketMath.h.

◆ predux_min< Packet8uc >()

Definition at line 2613 of file NEON/PacketMath.h.

◆ predux_min< Packet8us >() [1/2]

template<>
EIGEN_STRONG_INLINE unsigned short int Eigen::internal::predux_min< Packet8us > ( const Packet8us a)

Definition at line 1646 of file AltiVec/PacketMath.h.

◆ predux_min< Packet8us >() [2/2]

Definition at line 2645 of file NEON/PacketMath.h.

◆ predux_min< PacketXf >()

template<>
EIGEN_STRONG_INLINE float Eigen::internal::predux_min< PacketXf > ( const PacketXf &  a)

Definition at line 715 of file SVE/PacketMath.h.

◆ predux_min< PacketXi >()

template<>
EIGEN_STRONG_INLINE numext::int32_t Eigen::internal::predux_min< PacketXi > ( const PacketXi &  a)

Definition at line 339 of file SVE/PacketMath.h.

◆ predux_mul()

template<typename Packet >
EIGEN_DEVICE_FUNC unpacket_traits<Packet>::type Eigen::internal::predux_mul ( const Packet a)
inline

Definition at line 882 of file GenericPacketMath.h.

◆ predux_mul< Packet16b >()

Definition at line 1054 of file SSE/PacketMath.h.

◆ predux_mul< Packet16bf >()

Definition at line 2126 of file AVX512/PacketMath.h.

◆ predux_mul< Packet16c >() [1/2]

template<>
EIGEN_STRONG_INLINE signed char Eigen::internal::predux_mul< Packet16c > ( const Packet16c a)

Definition at line 1578 of file AltiVec/PacketMath.h.

◆ predux_mul< Packet16c >() [2/2]

Definition at line 2515 of file NEON/PacketMath.h.

◆ predux_mul< Packet16f >()

Definition at line 1028 of file AVX512/PacketMath.h.

◆ predux_mul< Packet16h >()

Definition at line 1624 of file AVX512/PacketMath.h.

◆ predux_mul< Packet16uc >() [1/2]

template<>
EIGEN_STRONG_INLINE unsigned char Eigen::internal::predux_mul< Packet16uc > ( const Packet16uc a)

Definition at line 1590 of file AltiVec/PacketMath.h.

◆ predux_mul< Packet16uc >() [2/2]

Definition at line 2529 of file NEON/PacketMath.h.

◆ predux_mul< Packet1cd >()

template<>
EIGEN_STRONG_INLINE std::complex< double > Eigen::internal::predux_mul< Packet1cd > ( const Packet1cd a)

Definition at line 605 of file MSA/Complex.h.

◆ predux_mul< Packet1cf >()

template<>
EIGEN_STRONG_INLINE std::complex<float> Eigen::internal::predux_mul< Packet1cf > ( const Packet1cf a)

Definition at line 312 of file NEON/Complex.h.

◆ predux_mul< Packet2cd >()

template<>
EIGEN_STRONG_INLINE std::complex<double> Eigen::internal::predux_mul< Packet2cd > ( const Packet2cd a)

Definition at line 314 of file AVX/Complex.h.

◆ predux_mul< Packet2cf >()

template<>
EIGEN_STRONG_INLINE std::complex< float > Eigen::internal::predux_mul< Packet2cf > ( const Packet2cf a)

Definition at line 199 of file AltiVec/Complex.h.

◆ predux_mul< Packet2d >()

Definition at line 1092 of file MSA/PacketMath.h.

◆ predux_mul< Packet2f >()

Definition at line 2499 of file NEON/PacketMath.h.

◆ predux_mul< Packet2i >()

Definition at line 2563 of file NEON/PacketMath.h.

◆ predux_mul< Packet2l >()

Definition at line 2571 of file NEON/PacketMath.h.

◆ predux_mul< Packet2ui >()

Definition at line 2567 of file NEON/PacketMath.h.

◆ predux_mul< Packet2ul >()

Definition at line 2573 of file NEON/PacketMath.h.

◆ predux_mul< Packet4bf >()

Definition at line 3581 of file NEON/PacketMath.h.

◆ predux_mul< Packet4c >()

Definition at line 2503 of file NEON/PacketMath.h.

◆ predux_mul< Packet4cd >()

template<>
EIGEN_STRONG_INLINE std::complex<double> Eigen::internal::predux_mul< Packet4cd > ( const Packet4cd a)

Definition at line 306 of file AVX512/Complex.h.

◆ predux_mul< Packet4cf >()

template<>
EIGEN_STRONG_INLINE std::complex<float> Eigen::internal::predux_mul< Packet4cf > ( const Packet4cf a)

Definition at line 164 of file AVX/Complex.h.

◆ predux_mul< Packet4d >()

Definition at line 819 of file AVX/PacketMath.h.

◆ predux_mul< Packet4f >()

Definition at line 1533 of file AltiVec/PacketMath.h.

◆ predux_mul< Packet4i >() [1/2]

Definition at line 596 of file MSA/PacketMath.h.

◆ predux_mul< Packet4i >() [2/2]

Definition at line 1540 of file AltiVec/PacketMath.h.

◆ predux_mul< Packet4s >()

Definition at line 2531 of file NEON/PacketMath.h.

◆ predux_mul< Packet4uc >()

Definition at line 2517 of file NEON/PacketMath.h.

◆ predux_mul< Packet4ui >()

Definition at line 2569 of file NEON/PacketMath.h.

◆ predux_mul< Packet4us >()

Definition at line 2547 of file NEON/PacketMath.h.

◆ predux_mul< Packet8bf >()

Definition at line 1569 of file AltiVec/PacketMath.h.

◆ predux_mul< Packet8c >()

Definition at line 2509 of file NEON/PacketMath.h.

◆ predux_mul< Packet8cf >()

template<>
EIGEN_STRONG_INLINE std::complex<float> Eigen::internal::predux_mul< Packet8cf > ( const Packet8cf a)

Definition at line 142 of file AVX512/Complex.h.

◆ predux_mul< Packet8d >()

Definition at line 1048 of file AVX512/PacketMath.h.

◆ predux_mul< Packet8f >()

Definition at line 812 of file AVX/PacketMath.h.

◆ predux_mul< Packet8h >()

Definition at line 1173 of file AVX/PacketMath.h.

◆ predux_mul< Packet8s >() [1/2]

Definition at line 1547 of file AltiVec/PacketMath.h.

◆ predux_mul< Packet8s >() [2/2]

Definition at line 2536 of file NEON/PacketMath.h.

◆ predux_mul< Packet8uc >()

Definition at line 2523 of file NEON/PacketMath.h.

◆ predux_mul< Packet8us >() [1/2]

template<>
EIGEN_STRONG_INLINE unsigned short int Eigen::internal::predux_mul< Packet8us > ( const Packet8us a)

Definition at line 1558 of file AltiVec/PacketMath.h.

◆ predux_mul< Packet8us >() [2/2]

Definition at line 2552 of file NEON/PacketMath.h.

◆ predux_mul< PacketXf >()

template<>
EIGEN_STRONG_INLINE float Eigen::internal::predux_mul< PacketXf > ( const PacketXf &  a)

Definition at line 681 of file SVE/PacketMath.h.

◆ predux_mul< PacketXi >()

template<>
EIGEN_STRONG_INLINE numext::int32_t Eigen::internal::predux_mul< PacketXi > ( const PacketXi &  a)

Definition at line 304 of file SVE/PacketMath.h.

◆ prefetch()

template<typename Scalar >
EIGEN_DEVICE_FUNC void Eigen::internal::prefetch ( const Scalar addr)
inline

Definition at line 719 of file GenericPacketMath.h.

◆ prefetch< double >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::prefetch< double > ( const double *  addr)

Definition at line 692 of file AVX/PacketMath.h.

◆ prefetch< float >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::prefetch< float > ( const float *  addr)

Definition at line 1117 of file AltiVec/PacketMath.h.

◆ prefetch< int >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int > ( const int addr)

Definition at line 1118 of file AltiVec/PacketMath.h.

◆ prefetch< int16_t >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int16_t > ( const int16_t addr)

Definition at line 2272 of file NEON/PacketMath.h.

◆ prefetch< int32_t >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int32_t > ( const int32_t addr)

Definition at line 516 of file MSA/PacketMath.h.

◆ prefetch< int64_t >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int64_t > ( const int64_t addr)

Definition at line 2276 of file NEON/PacketMath.h.

◆ prefetch< int8_t >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int8_t > ( const int8_t addr)

Definition at line 2270 of file NEON/PacketMath.h.

◆ prefetch< numext::int32_t >()

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

◆ prefetch< std::complex< double > >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::prefetch< std::complex< double > > ( const std::complex< double > *  addr)

Definition at line 556 of file MSA/Complex.h.

◆ prefetch< std::complex< float > >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::prefetch< std::complex< float > > ( const std::complex< float > *  addr)

Definition at line 174 of file AltiVec/Complex.h.

◆ prefetch< uint16_t >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::prefetch< uint16_t > ( const uint16_t addr)

Definition at line 2273 of file NEON/PacketMath.h.

◆ prefetch< uint32_t >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::prefetch< uint32_t > ( const uint32_t addr)

Definition at line 2275 of file NEON/PacketMath.h.

◆ prefetch< uint64_t >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::prefetch< uint64_t > ( const uint64_t addr)

Definition at line 2277 of file NEON/PacketMath.h.

◆ prefetch< uint8_t >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::prefetch< uint8_t > ( const uint8_t addr)

Definition at line 2271 of file NEON/PacketMath.h.

◆ preinterpret()

template<typename Target , typename Packet >
EIGEN_DEVICE_FUNC Target Eigen::internal::preinterpret ( const Packet a)
inline

◆ preinterpret< Packet16c, Packet16uc >()

Definition at line 1112 of file NEON/TypeCasting.h.

◆ preinterpret< Packet16f, Packet16i >()

Definition at line 29 of file AVX512/TypeCasting.h.

◆ preinterpret< Packet16i, Packet16f >()

Definition at line 25 of file AVX512/TypeCasting.h.

◆ preinterpret< Packet16uc, Packet16c >()

Definition at line 1125 of file NEON/TypeCasting.h.

◆ preinterpret< Packet2d, Packet4i >()

Definition at line 80 of file SSE/TypeCasting.h.

◆ preinterpret< Packet2f, Packet2i >()

Definition at line 1087 of file NEON/TypeCasting.h.

◆ preinterpret< Packet2f, Packet2ui >()

Definition at line 1091 of file NEON/TypeCasting.h.

◆ preinterpret< Packet2i, Packet2f >()

Definition at line 1148 of file NEON/TypeCasting.h.

◆ preinterpret< Packet2i, Packet2ui >()

Definition at line 1152 of file NEON/TypeCasting.h.

◆ preinterpret< Packet2l, Packet2ul >()

Definition at line 1182 of file NEON/TypeCasting.h.

◆ preinterpret< Packet2ui, Packet2f >()

Definition at line 1165 of file NEON/TypeCasting.h.

◆ preinterpret< Packet2ui, Packet2i >()

Definition at line 1169 of file NEON/TypeCasting.h.

◆ preinterpret< Packet2ul, Packet2l >()

Definition at line 1186 of file NEON/TypeCasting.h.

◆ preinterpret< Packet4c, Packet4uc >()

Definition at line 1104 of file NEON/TypeCasting.h.

◆ preinterpret< Packet4f, Packet4i >()

Definition at line 2248 of file AltiVec/PacketMath.h.

◆ preinterpret< Packet4f, Packet4ui >()

Definition at line 1099 of file NEON/TypeCasting.h.

◆ preinterpret< Packet4i, Packet2d >()

Definition at line 84 of file SSE/TypeCasting.h.

◆ preinterpret< Packet4i, Packet4f >()

Definition at line 2244 of file AltiVec/PacketMath.h.

◆ preinterpret< Packet4i, Packet4ui >()

Definition at line 1160 of file NEON/TypeCasting.h.

◆ preinterpret< Packet4s, Packet4us >()

Definition at line 1130 of file NEON/TypeCasting.h.

◆ preinterpret< Packet4uc, Packet4c >()

Definition at line 1117 of file NEON/TypeCasting.h.

◆ preinterpret< Packet4ui, Packet4f >()

Definition at line 1173 of file NEON/TypeCasting.h.

◆ preinterpret< Packet4ui, Packet4i >()

Definition at line 1177 of file NEON/TypeCasting.h.

◆ preinterpret< Packet4us, Packet4s >()

Definition at line 1139 of file NEON/TypeCasting.h.

◆ preinterpret< Packet8c, Packet8uc >()

Definition at line 1108 of file NEON/TypeCasting.h.

◆ preinterpret< Packet8f, Packet8i >()

Definition at line 91 of file AVX/TypeCasting.h.

◆ preinterpret< Packet8i, Packet8f >()

Definition at line 87 of file AVX/TypeCasting.h.

◆ preinterpret< Packet8s, Packet8us >()

Definition at line 1134 of file NEON/TypeCasting.h.

◆ preinterpret< Packet8uc, Packet8c >()

Definition at line 1121 of file NEON/TypeCasting.h.

◆ preinterpret< Packet8us, Packet8s >()

Definition at line 1143 of file NEON/TypeCasting.h.

◆ preinterpret< PacketXf, PacketXi >()

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::preinterpret< PacketXf, PacketXi > ( const PacketXi &  a)

Definition at line 37 of file SVE/TypeCasting.h.

◆ preinterpret< PacketXi, PacketXf >()

template<>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::preinterpret< PacketXi, PacketXf > ( const PacketXf &  a)

Definition at line 42 of file SVE/TypeCasting.h.

◆ preverse() [1/38]

template<>
EIGEN_STRONG_INLINE Packet8cf Eigen::internal::preverse ( const Packet8cf a)

Definition at line 130 of file AVX512/Complex.h.

◆ preverse() [2/38]

template<>
EIGEN_STRONG_INLINE Packet4cf Eigen::internal::preverse ( const Packet4cf a)

Definition at line 145 of file AVX/Complex.h.

◆ preverse() [3/38]

template<>
EIGEN_STRONG_INLINE Packet2cf Eigen::internal::preverse ( const Packet2cf a)

Definition at line 184 of file AltiVec/Complex.h.

◆ preverse() [4/38]

template<>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::preverse ( const PacketXi &  a)

Definition at line 286 of file SVE/PacketMath.h.

◆ preverse() [5/38]

template<>
EIGEN_STRONG_INLINE Packet1cf Eigen::internal::preverse ( const Packet1cf a)

Definition at line 290 of file NEON/Complex.h.

◆ preverse() [6/38]

template<>
EIGEN_STRONG_INLINE Packet4cd Eigen::internal::preverse ( const Packet4cd a)

Definition at line 296 of file AVX512/Complex.h.

◆ preverse() [7/38]

template<>
EIGEN_STRONG_INLINE Packet2cd Eigen::internal::preverse ( const Packet2cd a)

Definition at line 303 of file AVX/Complex.h.

◆ preverse() [8/38]

template<>
EIGEN_STRONG_INLINE Packet1cd Eigen::internal::preverse ( const Packet1cd a)

Definition at line 591 of file MSA/Complex.h.

◆ preverse() [9/38]

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::preverse ( const PacketXf &  a)

Definition at line 652 of file SVE/PacketMath.h.

◆ preverse() [10/38]

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::preverse ( const Packet8f a)

Definition at line 707 of file AVX/PacketMath.h.

◆ preverse() [11/38]

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::preverse ( const Packet4d a)

Definition at line 712 of file AVX/PacketMath.h.

◆ preverse() [12/38]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::preverse ( const Packet a)
inline

Definition at line 737 of file GenericPacketMath.h.

◆ preverse() [13/38]

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::preverse ( const Packet16f a)

Definition at line 875 of file AVX512/PacketMath.h.

◆ preverse() [14/38]

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::preverse ( const Packet8d a)

Definition at line 880 of file AVX512/PacketMath.h.

◆ preverse() [15/38]

template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::preverse ( const Packet16b a)

Definition at line 894 of file SSE/PacketMath.h.

◆ preverse() [16/38]

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::preverse ( const Packet2d a)

Definition at line 1068 of file MSA/PacketMath.h.

◆ preverse() [17/38]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::preverse ( const Packet4f a)

Definition at line 1147 of file AltiVec/PacketMath.h.

◆ preverse() [18/38]

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::preverse ( const Packet4i a)

Definition at line 1151 of file AltiVec/PacketMath.h.

◆ preverse() [19/38]

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::preverse ( const Packet8s a)

Definition at line 1155 of file AltiVec/PacketMath.h.

◆ preverse() [20/38]

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::preverse ( const Packet8us a)

Definition at line 1159 of file AltiVec/PacketMath.h.

◆ preverse() [21/38]

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::preverse ( const Packet16c a)

Definition at line 1163 of file AltiVec/PacketMath.h.

◆ preverse() [22/38]

template<>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::preverse ( const Packet16uc a)

Definition at line 1167 of file AltiVec/PacketMath.h.

◆ preverse() [23/38]

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::preverse ( const Packet8bf a)

Definition at line 1171 of file AltiVec/PacketMath.h.

◆ preverse() [24/38]

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::preverse ( const Packet8h a)

Definition at line 1179 of file AVX/PacketMath.h.

◆ preverse() [25/38]

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::preverse ( const Packet16h a)

Definition at line 1629 of file AVX512/PacketMath.h.

◆ preverse() [26/38]

template<>
EIGEN_STRONG_INLINE Packet16bf Eigen::internal::preverse ( const Packet16bf a)

Definition at line 2141 of file AVX512/PacketMath.h.

◆ preverse() [27/38]

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::preverse ( const Packet2f a)

Definition at line 2298 of file NEON/PacketMath.h.

◆ preverse() [28/38]

template<>
EIGEN_STRONG_INLINE Packet4c Eigen::internal::preverse ( const Packet4c a)

Definition at line 2304 of file NEON/PacketMath.h.

◆ preverse() [29/38]

template<>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::preverse ( const Packet8c a)

Definition at line 2306 of file NEON/PacketMath.h.

◆ preverse() [30/38]

template<>
EIGEN_STRONG_INLINE Packet4uc Eigen::internal::preverse ( const Packet4uc a)

Definition at line 2312 of file NEON/PacketMath.h.

◆ preverse() [31/38]

template<>
EIGEN_STRONG_INLINE Packet8uc Eigen::internal::preverse ( const Packet8uc a)

Definition at line 2314 of file NEON/PacketMath.h.

◆ preverse() [32/38]

template<>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::preverse ( const Packet4s a)

Definition at line 2320 of file NEON/PacketMath.h.

◆ preverse() [33/38]

template<>
EIGEN_STRONG_INLINE Packet4us Eigen::internal::preverse ( const Packet4us a)

Definition at line 2326 of file NEON/PacketMath.h.

◆ preverse() [34/38]

template<>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::preverse ( const Packet2i a)

Definition at line 2332 of file NEON/PacketMath.h.

◆ preverse() [35/38]

template<>
EIGEN_STRONG_INLINE Packet2ui Eigen::internal::preverse ( const Packet2ui a)

Definition at line 2338 of file NEON/PacketMath.h.

◆ preverse() [36/38]

template<>
EIGEN_STRONG_INLINE Packet4ui Eigen::internal::preverse ( const Packet4ui a)

Definition at line 2339 of file NEON/PacketMath.h.

◆ preverse() [37/38]

template<>
EIGEN_STRONG_INLINE Packet2l Eigen::internal::preverse ( const Packet2l a)

Definition at line 2344 of file NEON/PacketMath.h.

◆ preverse() [38/38]

template<>
EIGEN_STRONG_INLINE Packet2ul Eigen::internal::preverse ( const Packet2ul a)

Definition at line 2346 of file NEON/PacketMath.h.

◆ preverse< Packet4bf >()

Definition at line 3586 of file NEON/PacketMath.h.

◆ print() [1/4]

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::print ( const Packet2d a)

Definition at line 660 of file SSE/PacketMath.h.

◆ print() [2/4]

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::print ( const Packet a)

Definition at line 835 of file GenericPacketMath.h.

◆ print() [3/4]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::print ( const Packet4f a)

Definition at line 3115 of file NEON/PacketMath.h.

◆ print() [4/4]

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::print ( const Packet2f a)

Definition at line 3129 of file NEON/PacketMath.h.

◆ print< Packet16bf >()

Definition at line 2019 of file AVX512/PacketMath.h.

◆ print< Packet16f >()

Definition at line 526 of file AVX512/PacketMath.h.

◆ print< Packet16h >()

Definition at line 1535 of file AVX512/PacketMath.h.

◆ print< Packet4bf >()

Definition at line 3521 of file NEON/PacketMath.h.

◆ print< Packet4d >()

Definition at line 450 of file AVX/PacketMath.h.

◆ print< Packet4f >()

Definition at line 940 of file AltiVec/PacketMath.h.

◆ print< Packet8bf >()

Definition at line 1393 of file AltiVec/PacketMath.h.

◆ print< Packet8d >()

Definition at line 527 of file AVX512/PacketMath.h.

◆ print< Packet8f >()

Definition at line 449 of file AVX/PacketMath.h.

◆ print< Packet8h >()

Definition at line 1065 of file AVX/PacketMath.h.

◆ print_matrix()

template<typename Derived >
std::ostream & Eigen::internal::print_matrix ( std::ostream &  s,
const Derived &  _m,
const IOFormat fmt 
)

Definition at line 131 of file IO.h.

◆ pround()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pround ( const Packet a)

Definition at line 826 of file GenericPacketMath.h.

◆ pround< Packet16bf >()

Definition at line 2014 of file AVX512/PacketMath.h.

◆ pround< Packet16f >()

Definition at line 651 of file AVX512/PacketMath.h.

◆ pround< Packet16h >()

Definition at line 1531 of file AVX512/PacketMath.h.

◆ pround< Packet2d >()

Definition at line 1202 of file MSA/PacketMath.h.

◆ pround< Packet4d >()

Definition at line 535 of file AVX/PacketMath.h.

◆ pround< Packet4f >()

Definition at line 921 of file AltiVec/PacketMath.h.

◆ pround< Packet8bf >()

Definition at line 1390 of file AltiVec/PacketMath.h.

◆ pround< Packet8d >()

Definition at line 658 of file AVX512/PacketMath.h.

◆ pround< Packet8f >()

Definition at line 529 of file AVX/PacketMath.h.

◆ pround< Packet8h >()

Definition at line 1061 of file AVX/PacketMath.h.

◆ prsqrt() [1/4]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::prsqrt ( const Packet4f a)

Definition at line 730 of file MSA/PacketMath.h.

◆ prsqrt() [2/4]

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::prsqrt ( const Packet a)

Definition at line 819 of file GenericPacketMath.h.

◆ prsqrt() [3/4]

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::prsqrt ( const Packet2d a)

Definition at line 1137 of file MSA/PacketMath.h.

◆ prsqrt() [4/4]

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::prsqrt ( const Packet2f a)

Definition at line 3286 of file NEON/PacketMath.h.

◆ prsqrt< Packet2d >()

Definition at line 160 of file Eigen/src/Core/arch/SSE/MathFunctions.h.

◆ prsqrt< Packet4d >()

Definition at line 171 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ prsqrt< Packet4f >()

Definition at line 45 of file Eigen/src/Core/arch/AltiVec/MathFunctions.h.

◆ prsqrt< Packet8bf >()

Definition at line 1347 of file AltiVec/PacketMath.h.

◆ prsqrt< Packet8f >()

Definition at line 164 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ pscatter()

template<typename Scalar , typename Packet >
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter ( Scalar to,
const Packet from,
Index   
)
inline

Definition at line 715 of file GenericPacketMath.h.

◆ pscatter< bfloat16, Packet16bf >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pscatter< bfloat16, Packet16bf > ( bfloat16 to,
const Packet16bf from,
Index  stride 
)

Definition at line 2163 of file AVX512/PacketMath.h.

◆ pscatter< bfloat16, Packet4bf >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pscatter< bfloat16, Packet4bf > ( bfloat16 to,
const Packet4bf from,
Index  stride 
)

Definition at line 3561 of file NEON/PacketMath.h.

◆ pscatter< bfloat16, Packet8bf >() [1/2]

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< bfloat16, Packet8bf > ( bfloat16 to,
const Packet8bf from,
Index  stride 
)
inline

Definition at line 730 of file AltiVec/PacketMath.h.

◆ pscatter< bfloat16, Packet8bf >() [2/2]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pscatter< bfloat16, Packet8bf > ( bfloat16 to,
const Packet8bf from,
Index  stride 
)

Definition at line 1477 of file AVX/PacketMath.h.

◆ pscatter< bool, Packet16b >()

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< bool, Packet16b > ( bool *  to,
const Packet16b from,
Index  stride 
)
inline

Definition at line 839 of file SSE/PacketMath.h.

◆ pscatter< double, Packet2d >()

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< double, Packet2d > ( double *  to,
const Packet2d from,
Index  stride 
)
inline

Definition at line 1044 of file MSA/PacketMath.h.

◆ pscatter< double, Packet4d >()

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< double, Packet4d > ( double *  to,
const Packet4d from,
Index  stride 
)
inline

Definition at line 664 of file AVX/PacketMath.h.

◆ pscatter< double, Packet8d >()

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< double, Packet8d > ( double *  to,
const Packet8d from,
Index  stride 
)
inline

Definition at line 833 of file AVX512/PacketMath.h.

◆ pscatter< Eigen::half, Packet8h >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pscatter< Eigen::half, Packet8h > ( Eigen::half to,
const Packet8h from,
Index  stride 
)

Definition at line 1141 of file AVX/PacketMath.h.

◆ pscatter< float, Packet16f >()

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, Packet16f > ( float *  to,
const Packet16f from,
Index  stride 
)
inline

Definition at line 823 of file AVX512/PacketMath.h.

◆ pscatter< float, Packet2f >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< float, Packet2f > ( float *  to,
const Packet2f from,
Index  stride 
)

Definition at line 2116 of file NEON/PacketMath.h.

◆ pscatter< float, Packet4f >() [1/2]

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, Packet4f > ( float *  to,
const Packet4f from,
Index  stride 
)
inline

Definition at line 695 of file AltiVec/PacketMath.h.

◆ pscatter< float, Packet4f >() [2/2]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< float, Packet4f > ( float *  to,
const Packet4f from,
Index  stride 
)

Definition at line 2121 of file NEON/PacketMath.h.

◆ pscatter< float, Packet8f >()

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, Packet8f > ( float *  to,
const Packet8f from,
Index  stride 
)
inline

Definition at line 650 of file AVX/PacketMath.h.

◆ pscatter< float, PacketXf >()

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, PacketXf > ( float *  to,
const PacketXf &  from,
Index  stride 
)
inline

Definition at line 637 of file SVE/PacketMath.h.

◆ pscatter< half, Packet16h >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pscatter< half, Packet16h > ( half to,
const Packet16h from,
Index  stride 
)

Definition at line 1646 of file AVX512/PacketMath.h.

◆ pscatter< int, Packet4i >()

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< int, Packet4i > ( int to,
const Packet4i from,
Index  stride 
)
inline

Definition at line 700 of file AltiVec/PacketMath.h.

◆ pscatter< int16_t, Packet4s >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< int16_t, Packet4s > ( int16_t to,
const Packet4s from,
Index  stride 
)

Definition at line 2198 of file NEON/PacketMath.h.

◆ pscatter< int16_t, Packet8s >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< int16_t, Packet8s > ( int16_t to,
const Packet8s from,
Index  stride 
)

Definition at line 2205 of file NEON/PacketMath.h.

◆ pscatter< int32_t, Packet2i >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< int32_t, Packet2i > ( int32_t to,
const Packet2i from,
Index  stride 
)

Definition at line 2234 of file NEON/PacketMath.h.

◆ pscatter< int32_t, Packet4i >() [1/2]

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< int32_t, Packet4i > ( int32_t to,
const Packet4i from,
Index  stride 
)
inline

Definition at line 495 of file MSA/PacketMath.h.

◆ pscatter< int32_t, Packet4i >() [2/2]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< int32_t, Packet4i > ( int32_t to,
const Packet4i from,
Index  stride 
)

Definition at line 2239 of file NEON/PacketMath.h.

◆ pscatter< int64_t, Packet2l >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< int64_t, Packet2l > ( int64_t to,
const Packet2l from,
Index  stride 
)

Definition at line 2258 of file NEON/PacketMath.h.

◆ pscatter< int8_t, Packet16c >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< int8_t, Packet16c > ( int8_t to,
const Packet16c from,
Index  stride 
)

Definition at line 2144 of file NEON/PacketMath.h.

◆ pscatter< int8_t, Packet4c >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< int8_t, Packet4c > ( int8_t to,
const Packet4c from,
Index  stride 
)

Definition at line 2128 of file NEON/PacketMath.h.

◆ pscatter< int8_t, Packet8c >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< int8_t, Packet8c > ( int8_t to,
const Packet8c from,
Index  stride 
)

Definition at line 2133 of file NEON/PacketMath.h.

◆ pscatter< numext::int32_t, PacketXi >()

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< numext::int32_t, PacketXi > ( numext::int32_t to,
const PacketXi &  from,
Index  stride 
)
inline

Definition at line 271 of file SVE/PacketMath.h.

◆ pscatter< short int, Packet8s >()

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< short int, Packet8s > ( short int to,
const Packet8s from,
Index  stride 
)
inline

Definition at line 720 of file AltiVec/PacketMath.h.

◆ pscatter< signed char, Packet16c >()

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< signed char, Packet16c > ( signed char *  to,
const Packet16c from,
Index  stride 
)
inline

Definition at line 757 of file AltiVec/PacketMath.h.

◆ pscatter< std::complex< double >, Packet1cd >() [1/2]

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< double >, Packet1cd > ( std::complex< double > *  to,
const Packet1cd from,
Index stride  EIGEN_UNUSED 
)
inline

Definition at line 113 of file ZVector/Complex.h.

◆ pscatter< std::complex< double >, Packet1cd >() [2/2]

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< double >, Packet1cd > ( std::complex< double > *  to,
const Packet1cd from,
Index stride   __attribute__(unused) 
)
inline

Definition at line 574 of file MSA/Complex.h.

◆ 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

Definition at line 287 of file AVX/Complex.h.

◆ pscatter< std::complex< double >, Packet4cd >()

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< double >, Packet4cd > ( std::complex< double > *  to,
const Packet4cd from,
Index  stride 
)
inline

Definition at line 278 of file AVX512/Complex.h.

◆ pscatter< std::complex< float >, Packet1cf >()

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< float >, Packet1cf > ( std::complex< float > *  to,
const Packet1cf from,
Index  stride 
)
inline

Definition at line 264 of file NEON/Complex.h.

◆ pscatter< std::complex< float >, Packet2cf >()

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< float >, Packet2cf > ( std::complex< float > *  to,
const Packet2cf from,
Index  stride 
)
inline

Definition at line 156 of file AltiVec/Complex.h.

◆ 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

Definition at line 124 of file AVX/Complex.h.

◆ pscatter< std::complex< float >, Packet8cf >()

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< std::complex< float >, Packet8cf > ( std::complex< float > *  to,
const Packet8cf from,
Index  stride 
)
inline

Definition at line 120 of file AVX512/Complex.h.

◆ pscatter< uint16_t, Packet4us >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< uint16_t, Packet4us > ( uint16_t to,
const Packet4us from,
Index  stride 
)

Definition at line 2216 of file NEON/PacketMath.h.

◆ pscatter< uint16_t, Packet8us >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< uint16_t, Packet8us > ( uint16_t to,
const Packet8us from,
Index  stride 
)

Definition at line 2223 of file NEON/PacketMath.h.

◆ pscatter< uint32_t, Packet2ui >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< uint32_t, Packet2ui > ( uint32_t to,
const Packet2ui from,
Index  stride 
)

Definition at line 2246 of file NEON/PacketMath.h.

◆ pscatter< uint32_t, Packet4ui >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< uint32_t, Packet4ui > ( uint32_t to,
const Packet4ui from,
Index  stride 
)

Definition at line 2251 of file NEON/PacketMath.h.

◆ pscatter< uint64_t, Packet2ul >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< uint64_t, Packet2ul > ( uint64_t to,
const Packet2ul from,
Index  stride 
)

Definition at line 2263 of file NEON/PacketMath.h.

◆ pscatter< uint8_t, Packet16uc >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< uint8_t, Packet16uc > ( uint8_t to,
const Packet16uc from,
Index  stride 
)

Definition at line 2179 of file NEON/PacketMath.h.

◆ pscatter< uint8_t, Packet4uc >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< uint8_t, Packet4uc > ( uint8_t to,
const Packet4uc from,
Index  stride 
)

Definition at line 2163 of file NEON/PacketMath.h.

◆ pscatter< uint8_t, Packet8uc >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::pscatter< uint8_t, Packet8uc > ( uint8_t to,
const Packet8uc from,
Index  stride 
)

Definition at line 2168 of file NEON/PacketMath.h.

◆ pscatter< unsigned char, Packet16uc >()

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< unsigned char, Packet16uc > ( unsigned char *  to,
const Packet16uc from,
Index  stride 
)
inline

Definition at line 762 of file AltiVec/PacketMath.h.

◆ pscatter< unsigned short int, Packet8us >()

template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< unsigned short int, Packet8us > ( unsigned short int to,
const Packet8us from,
Index  stride 
)
inline

Definition at line 725 of file AltiVec/PacketMath.h.

◆ pscatter_size16()

template<typename Packet >
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter_size16 ( __UNPACK_TYPE__(Packet) *  to,
const Packet from,
Index  stride 
)
inline

Definition at line 735 of file AltiVec/PacketMath.h.

◆ pscatter_size4()

template<typename Packet >
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter_size4 ( __UNPACK_TYPE__(Packet) *  to,
const Packet from,
Index  stride 
)
inline

Definition at line 685 of file AltiVec/PacketMath.h.

◆ pscatter_size8()

template<typename Packet >
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter_size8 ( __UNPACK_TYPE__(Packet) *  to,
const Packet from,
Index  stride 
)
inline

Definition at line 705 of file AltiVec/PacketMath.h.

◆ pselect() [1/26]

template<>
EIGEN_DEVICE_FUNC Packet16f Eigen::internal::pselect ( const Packet16f mask,
const Packet16f a,
const Packet16f b 
)
inline

Definition at line 353 of file AVX512/PacketMath.h.

◆ pselect() [2/26]

template<>
EIGEN_DEVICE_FUNC Packet8d Eigen::internal::pselect ( const Packet8d mask,
const Packet8d a,
const Packet8d b 
)
inline

Definition at line 362 of file AVX512/PacketMath.h.

◆ pselect() [3/26]

template<>
EIGEN_DEVICE_FUNC Packet16b Eigen::internal::pselect ( const Packet16b mask,
const Packet16b a,
const Packet16b b 
)
inline

Definition at line 391 of file SSE/PacketMath.h.

◆ pselect() [4/26]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pselect ( const Packet mask,
const Packet a,
const Packet b 
)
inline

Definition at line 452 of file GenericPacketMath.h.

◆ pselect() [5/26]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pselect ( const Packet4f mask,
const Packet4f a,
const Packet4f b 
)

Definition at line 917 of file AltiVec/PacketMath.h.

◆ pselect() [6/26]

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::pselect ( const Packet8h mask,
const Packet8h a,
const Packet8h b 
)

Definition at line 1057 of file AVX/PacketMath.h.

◆ pselect() [7/26]

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pselect ( const Packet8bf mask,
const Packet8bf a,
const Packet8bf b 
)

Definition at line 1403 of file AVX/PacketMath.h.

◆ pselect() [8/26]

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::pselect ( const Packet16h mask,
const Packet16h a,
const Packet16h b 
)

Definition at line 1527 of file AVX512/PacketMath.h.

◆ pselect() [9/26]

template<>
EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pselect ( const Packet16bf mask,
const Packet16bf a,
const Packet16bf b 
)

Definition at line 2006 of file AVX512/PacketMath.h.

◆ pselect() [10/26]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2f Eigen::internal::pselect ( const Packet2f mask,
const Packet2f a,
const Packet2f b 
)

Definition at line 3060 of file NEON/PacketMath.h.

◆ pselect() [11/26]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4f Eigen::internal::pselect ( const Packet4f mask,
const Packet4f a,
const Packet4f b 
)

Definition at line 3062 of file NEON/PacketMath.h.

◆ pselect() [12/26]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c Eigen::internal::pselect ( const Packet8c mask,
const Packet8c a,
const Packet8c b 
)

Definition at line 3064 of file NEON/PacketMath.h.

◆ pselect() [13/26]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16c Eigen::internal::pselect ( const Packet16c mask,
const Packet16c a,
const Packet16c b 
)

Definition at line 3066 of file NEON/PacketMath.h.

◆ pselect() [14/26]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pselect ( const Packet8uc mask,
const Packet8uc a,
const Packet8uc b 
)

Definition at line 3068 of file NEON/PacketMath.h.

◆ pselect() [15/26]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pselect ( const Packet16uc mask,
const Packet16uc a,
const Packet16uc b 
)

Definition at line 3070 of file NEON/PacketMath.h.

◆ pselect() [16/26]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s Eigen::internal::pselect ( const Packet4s mask,
const Packet4s a,
const Packet4s b 
)

Definition at line 3072 of file NEON/PacketMath.h.

◆ pselect() [17/26]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8s Eigen::internal::pselect ( const Packet8s mask,
const Packet8s a,
const Packet8s b 
)

Definition at line 3074 of file NEON/PacketMath.h.

◆ pselect() [18/26]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us Eigen::internal::pselect ( const Packet4us mask,
const Packet4us a,
const Packet4us b 
)

Definition at line 3076 of file NEON/PacketMath.h.

◆ pselect() [19/26]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8us Eigen::internal::pselect ( const Packet8us mask,
const Packet8us a,
const Packet8us b 
)

Definition at line 3078 of file NEON/PacketMath.h.

◆ pselect() [20/26]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2i Eigen::internal::pselect ( const Packet2i mask,
const Packet2i a,
const Packet2i b 
)

Definition at line 3080 of file NEON/PacketMath.h.

◆ pselect() [21/26]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4i Eigen::internal::pselect ( const Packet4i mask,
const Packet4i a,
const Packet4i b 
)

Definition at line 3082 of file NEON/PacketMath.h.

◆ pselect() [22/26]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pselect ( const Packet2ui mask,
const Packet2ui a,
const Packet2ui b 
)

Definition at line 3084 of file NEON/PacketMath.h.

◆ pselect() [23/26]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pselect ( const Packet4ui mask,
const Packet4ui a,
const Packet4ui b 
)

Definition at line 3086 of file NEON/PacketMath.h.

◆ pselect() [24/26]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2l Eigen::internal::pselect ( const Packet2l mask,
const Packet2l a,
const Packet2l b 
)

Definition at line 3088 of file NEON/PacketMath.h.

◆ pselect() [25/26]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pselect ( const Packet2ul mask,
const Packet2ul a,
const Packet2ul b 
)

Definition at line 3090 of file NEON/PacketMath.h.

◆ pselect() [26/26]

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pselect ( const Packet4bf mask,
const Packet4bf a,
const Packet4bf b 
)

Definition at line 3515 of file NEON/PacketMath.h.

◆ pselect< bool >()

template<>
EIGEN_DEVICE_FUNC bool Eigen::internal::pselect< bool > ( const bool &  cond,
const bool &  a,
const bool &  b 
)
inline

Definition at line 456 of file GenericPacketMath.h.

◆ pselect< Packet4d >()

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pselect< Packet4d > ( const Packet4d mask,
const Packet4d a,
const Packet4d b 
)

Definition at line 544 of file AVX/PacketMath.h.

◆ pselect< Packet8f >()

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pselect< Packet8f > ( const Packet8f mask,
const Packet8f a,
const Packet8f b 
)

Definition at line 542 of file AVX/PacketMath.h.

◆ pset1()

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pset1 ( const typename unpacket_traits< Packet >::type a)
inline

Definition at line 615 of file GenericPacketMath.h.

◆ pset1< Packet16b >()

template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::pset1< Packet16b > ( const bool &  from)

Definition at line 261 of file SSE/PacketMath.h.

◆ pset1< Packet16bf >()

Definition at line 1883 of file AVX512/PacketMath.h.

◆ pset1< Packet16c >()

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::pset1< Packet16c > ( const signed char &  from)

Definition at line 563 of file AltiVec/PacketMath.h.

◆ pset1< Packet16f >()

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pset1< Packet16f > ( const float &  from)

Definition at line 197 of file AVX512/PacketMath.h.

◆ pset1< Packet16h >()

Definition at line 1378 of file AVX512/PacketMath.h.

◆ pset1< Packet16i >()

Definition at line 205 of file AVX512/PacketMath.h.

◆ pset1< Packet16uc >()

template<>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::pset1< Packet16uc > ( const unsigned char &  from)

Definition at line 567 of file AltiVec/PacketMath.h.

◆ pset1< Packet1cd >()

template<>
EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pset1< Packet1cd > ( const std::complex< double > &  from)

Definition at line 463 of file MSA/Complex.h.

◆ pset1< Packet1cf >()

template<>
EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pset1< Packet1cf > ( const std::complex< float > &  from)

Definition at line 109 of file NEON/Complex.h.

◆ pset1< Packet2cd >()

template<>
EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pset1< Packet2cd > ( const std::complex< double > &  from)

Definition at line 269 of file AVX/Complex.h.

◆ pset1< Packet2cf >()

template<>
EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pset1< Packet2cf > ( const std::complex< float > &  from)

Definition at line 112 of file AltiVec/Complex.h.

◆ pset1< Packet2d >()

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pset1< Packet2d > ( const double &  from)

Definition at line 872 of file MSA/PacketMath.h.

◆ pset1< Packet2f >()

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::pset1< Packet2f > ( const float &  from)

Definition at line 694 of file NEON/PacketMath.h.

◆ pset1< Packet2i >()

Definition at line 708 of file NEON/PacketMath.h.

◆ pset1< Packet2l >()

Definition at line 712 of file NEON/PacketMath.h.

◆ pset1< Packet2ui >()

Definition at line 710 of file NEON/PacketMath.h.

◆ pset1< Packet2ul >()

Definition at line 713 of file NEON/PacketMath.h.

◆ pset1< Packet4bf >()

Definition at line 3423 of file NEON/PacketMath.h.

◆ pset1< Packet4c >()

Definition at line 696 of file NEON/PacketMath.h.

◆ pset1< Packet4cd >()

template<>
EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pset1< Packet4cd > ( const std::complex< double > &  from)

Definition at line 254 of file AVX512/Complex.h.

◆ pset1< Packet4cf >()

template<>
EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pset1< Packet4cf > ( const std::complex< float > &  from)

Definition at line 100 of file AVX/Complex.h.

◆ pset1< Packet4d >()

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pset1< Packet4d > ( const double &  from)

Definition at line 241 of file AVX/PacketMath.h.

◆ pset1< Packet4f >()

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pset1< Packet4f > ( const float &  from)

Definition at line 547 of file AltiVec/PacketMath.h.

◆ pset1< Packet4i >() [1/2]

Definition at line 137 of file MSA/PacketMath.h.

◆ pset1< Packet4i >() [2/2]

Definition at line 551 of file AltiVec/PacketMath.h.

◆ pset1< Packet4s >()

Definition at line 704 of file NEON/PacketMath.h.

◆ pset1< Packet4uc >()

Definition at line 700 of file NEON/PacketMath.h.

◆ pset1< Packet4ui >()

Definition at line 711 of file NEON/PacketMath.h.

◆ pset1< Packet4us >()

Definition at line 706 of file NEON/PacketMath.h.

◆ pset1< Packet8bf >()

Definition at line 575 of file AltiVec/PacketMath.h.

◆ pset1< Packet8c >()

Definition at line 698 of file NEON/PacketMath.h.

◆ pset1< Packet8cf >()

template<>
EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pset1< Packet8cf > ( const std::complex< float > &  from)

Definition at line 98 of file AVX512/Complex.h.

◆ pset1< Packet8d >()

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pset1< Packet8d > ( const double &  from)

Definition at line 201 of file AVX512/PacketMath.h.

◆ pset1< Packet8f >()

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pset1< Packet8f > ( const float &  from)

Definition at line 240 of file AVX/PacketMath.h.

◆ pset1< Packet8h >()

Definition at line 938 of file AVX/PacketMath.h.

◆ pset1< Packet8i >()

Definition at line 242 of file AVX/PacketMath.h.

◆ pset1< Packet8s >() [1/2]

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::pset1< Packet8s > ( const short int from)

Definition at line 555 of file AltiVec/PacketMath.h.

◆ pset1< Packet8s >() [2/2]

Definition at line 705 of file NEON/PacketMath.h.

◆ pset1< Packet8uc >()

Definition at line 702 of file NEON/PacketMath.h.

◆ pset1< Packet8us >() [1/2]

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::pset1< Packet8us > ( const unsigned short int from)

Definition at line 559 of file AltiVec/PacketMath.h.

◆ pset1< Packet8us >() [2/2]

Definition at line 707 of file NEON/PacketMath.h.

◆ pset1< PacketXf >()

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::pset1< PacketXf > ( const float &  from)

Definition at line 424 of file SVE/PacketMath.h.

◆ pset1< PacketXi >()

template<>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::pset1< PacketXi > ( const numext::int32_t from)

Definition at line 82 of file SVE/PacketMath.h.

◆ pset1_size16()

template<typename Packet >
EIGEN_STRONG_INLINE Packet Eigen::internal::pset1_size16 ( const __UNPACK_TYPE__(Packet)&  from)

Definition at line 541 of file AltiVec/PacketMath.h.

◆ pset1_size4()

template<typename Packet >
EIGEN_STRONG_INLINE Packet Eigen::internal::pset1_size4 ( const __UNPACK_TYPE__(Packet)&  from)

Definition at line 527 of file AltiVec/PacketMath.h.

◆ pset1_size8()

template<typename Packet >
EIGEN_STRONG_INLINE Packet Eigen::internal::pset1_size8 ( const __UNPACK_TYPE__(Packet)&  from)

Definition at line 534 of file AltiVec/PacketMath.h.

◆ pset1frombits()

template<typename Packet , typename BitsType >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pset1frombits ( BitsType  a)
inline

◆ pset1frombits< Packet16f >()

Definition at line 210 of file AVX512/PacketMath.h.

◆ pset1frombits< Packet2d >()

Definition at line 264 of file SSE/PacketMath.h.

◆ pset1frombits< Packet2f >()

Definition at line 715 of file NEON/PacketMath.h.

◆ pset1frombits< Packet4d >()

Definition at line 245 of file AVX/PacketMath.h.

◆ pset1frombits< Packet4f >()

Definition at line 571 of file AltiVec/PacketMath.h.

◆ pset1frombits< Packet8d >()

Definition at line 215 of file AVX512/PacketMath.h.

◆ pset1frombits< Packet8f >()

Definition at line 244 of file AVX/PacketMath.h.

◆ pset1frombits< PacketXf >()

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::pset1frombits< PacketXf > ( numext::uint32_t  from)

Definition at line 430 of file SVE/PacketMath.h.

◆ psin()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::psin ( const Packet a)

Definition at line 752 of file GenericPacketMath.h.

◆ psin< Packet16f >()

Definition at line 334 of file Eigen/src/Core/arch/AVX512/MathFunctions.h.

◆ psin< Packet2f >()

Definition at line 25 of file Eigen/src/Core/arch/NEON/MathFunctions.h.

◆ psin< Packet4f >()

Definition at line 32 of file Eigen/src/Core/arch/AltiVec/MathFunctions.h.

◆ psin< Packet8bf >()

Definition at line 1375 of file AltiVec/PacketMath.h.

◆ psin< Packet8f >()

Definition at line 23 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ psin< PacketXf >()

template<>
EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf Eigen::internal::psin< PacketXf > ( const PacketXf &  x)

Definition at line 27 of file Eigen/src/Core/arch/SVE/MathFunctions.h.

◆ psin_float()

template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::psin_float ( const Packet x)

Definition at line 747 of file GenericPacketMathFunctions.h.

◆ psincos_float()

template<bool ComputeSine, typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::psincos_float ( const Packet _x)

Definition at line 625 of file GenericPacketMathFunctions.h.

◆ psincos_inner_msa_float()

template<bool sine>
Packet4f Eigen::internal::psincos_inner_msa_float ( const Packet4f _x)

Definition at line 231 of file Eigen/src/Core/arch/MSA/MathFunctions.h.

◆ psinh()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::psinh ( const Packet a)

Definition at line 776 of file GenericPacketMath.h.

◆ psqrt() [1/11]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::psqrt ( const Packet4f a)

Definition at line 723 of file MSA/PacketMath.h.

◆ psqrt() [2/11]

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::psqrt ( const Packet a)

Definition at line 815 of file GenericPacketMath.h.

◆ psqrt() [3/11]

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::psqrt ( const Packet2d a)

Definition at line 1130 of file MSA/PacketMath.h.

◆ psqrt() [4/11]

template<>
EIGEN_STRONG_INLINE Packet4uc Eigen::internal::psqrt ( const Packet4uc a)

Computes the integer square root

Remarks
The calculation is performed using an algorithm which iterates through each binary digit of the result and tests whether setting that digit to 1 would cause the square of the value to be greater than the argument value. The algorithm is described in detail here: http://ww1.microchip.com/downloads/en/AppNotes/91040a.pdf .

Definition at line 3191 of file NEON/PacketMath.h.

◆ psqrt() [5/11]

template<>
EIGEN_STRONG_INLINE Packet8uc Eigen::internal::psqrt ( const Packet8uc a)

Computes the integer square root

Remarks
The calculation is performed using an algorithm which iterates through each binary digit of the result and tests whether setting that digit to 1 would cause the square of the value to be greater than the argument value. The algorithm is described in detail here: http://ww1.microchip.com/downloads/en/AppNotes/91040a.pdf .

Definition at line 3204 of file NEON/PacketMath.h.

◆ psqrt() [6/11]

template<>
EIGEN_STRONG_INLINE Packet16uc Eigen::internal::psqrt ( const Packet16uc a)

Computes the integer square root

Remarks
The calculation is performed using an algorithm which iterates through each binary digit of the result and tests whether setting that digit to 1 would cause the square of the value to be greater than the argument value. The algorithm is described in detail here: http://ww1.microchip.com/downloads/en/AppNotes/91040a.pdf .

Definition at line 3216 of file NEON/PacketMath.h.

◆ psqrt() [7/11]

template<>
EIGEN_STRONG_INLINE Packet4us Eigen::internal::psqrt ( const Packet4us a)

Computes the integer square root

Remarks
The calculation is performed using an algorithm which iterates through each binary digit of the result and tests whether setting that digit to 1 would cause the square of the value to be greater than the argument value. The algorithm is described in detail here: http://ww1.microchip.com/downloads/en/AppNotes/91040a.pdf .

Definition at line 3228 of file NEON/PacketMath.h.

◆ psqrt() [8/11]

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::psqrt ( const Packet8us a)

Computes the integer square root

Remarks
The calculation is performed using an algorithm which iterates through each binary digit of the result and tests whether setting that digit to 1 would cause the square of the value to be greater than the argument value. The algorithm is described in detail here: http://ww1.microchip.com/downloads/en/AppNotes/91040a.pdf .

Definition at line 3240 of file NEON/PacketMath.h.

◆ psqrt() [9/11]

template<>
EIGEN_STRONG_INLINE Packet2ui Eigen::internal::psqrt ( const Packet2ui a)

Computes the integer square root

Remarks
The calculation is performed using an algorithm which iterates through each binary digit of the result and tests whether setting that digit to 1 would cause the square of the value to be greater than the argument value. The algorithm is described in detail here: http://ww1.microchip.com/downloads/en/AppNotes/91040a.pdf .

Definition at line 3252 of file NEON/PacketMath.h.

◆ psqrt() [10/11]

template<>
EIGEN_STRONG_INLINE Packet4ui Eigen::internal::psqrt ( const Packet4ui a)

Computes the integer square root

Remarks
The calculation is performed using an algorithm which iterates through each binary digit of the result and tests whether setting that digit to 1 would cause the square of the value to be greater than the argument value. The algorithm is described in detail here: http://ww1.microchip.com/downloads/en/AppNotes/91040a.pdf .

Definition at line 3264 of file NEON/PacketMath.h.

◆ psqrt() [11/11]

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::psqrt ( const Packet2f a)

Definition at line 3306 of file NEON/PacketMath.h.

◆ psqrt< Packet16b >()

Definition at line 113 of file Eigen/src/Core/arch/SSE/MathFunctions.h.

◆ psqrt< Packet1cd >()

Definition at line 340 of file SSE/Complex.h.

◆ psqrt< Packet1cf >()

Definition at line 381 of file NEON/Complex.h.

◆ psqrt< Packet2cd >()

Definition at line 360 of file AVX/Complex.h.

◆ psqrt< Packet2cf >()

Definition at line 244 of file AltiVec/Complex.h.

◆ psqrt< Packet2d >()

Definition at line 110 of file Eigen/src/Core/arch/SSE/MathFunctions.h.

◆ psqrt< Packet4cd >()

Definition at line 411 of file AVX512/Complex.h.

◆ psqrt< Packet4cf >()

Definition at line 364 of file AVX/Complex.h.

◆ psqrt< Packet4d >()

Definition at line 125 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ psqrt< Packet4f >()

Definition at line 105 of file Eigen/src/Core/arch/SSE/MathFunctions.h.

◆ psqrt< Packet8bf >()

Definition at line 1344 of file AltiVec/PacketMath.h.

◆ psqrt< Packet8cf >()

Definition at line 415 of file AVX512/Complex.h.

◆ psqrt< Packet8f >()

Definition at line 118 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ psqrt_complex()

template<typename Packet >
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet Eigen::internal::psqrt_complex ( const Packet a)

Definition at line 764 of file GenericPacketMathFunctions.h.

◆ pstore()

template<typename Scalar , typename Packet >
EIGEN_DEVICE_FUNC void Eigen::internal::pstore ( Scalar to,
const Packet from 
)
inline

Definition at line 696 of file GenericPacketMath.h.

◆ pstore1()

template<typename Packet >
void Eigen::internal::pstore1 ( typename unpacket_traits< Packet >::type to,
const typename unpacket_traits< Packet >::type a 
)
inline

Definition at line 949 of file GenericPacketMath.h.

◆ pstore1< Packet16f >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet16f > ( float *  to,
const float &  a 
)

Definition at line 843 of file AVX512/PacketMath.h.

◆ pstore1< Packet16i >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet16i > ( int to,
const int a 
)

Definition at line 853 of file AVX512/PacketMath.h.

◆ pstore1< Packet2d >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet2d > ( double *  to,
const double &  a 
)

Definition at line 855 of file SSE/PacketMath.h.

◆ pstore1< Packet4d >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet4d > ( double *  to,
const double &  a 
)

Definition at line 679 of file AVX/PacketMath.h.

◆ pstore1< Packet4f >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet4f > ( float *  to,
const float &  a 
)

Definition at line 849 of file SSE/PacketMath.h.

◆ pstore1< Packet8d >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet8d > ( double *  to,
const double &  a 
)

Definition at line 848 of file AVX512/PacketMath.h.

◆ pstore1< Packet8f >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet8f > ( float *  to,
const float &  a 
)

Definition at line 674 of file AVX/PacketMath.h.

◆ pstore1< Packet8i >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet8i > ( int to,
const int a 
)

Definition at line 684 of file AVX/PacketMath.h.

◆ pstore< bfloat16 >() [1/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< bfloat16 > ( bfloat16 to,
const Packet8bf from 
)

Definition at line 511 of file AltiVec/PacketMath.h.

◆ pstore< bfloat16 >() [2/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< bfloat16 > ( bfloat16 to,
const Packet16bf from 
)

Definition at line 1905 of file AVX512/PacketMath.h.

◆ pstore< bfloat16 >() [3/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< bfloat16 > ( bfloat16 to,
const Packet4bf from 
)

Definition at line 3441 of file NEON/PacketMath.h.

◆ pstore< bool >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< bool > ( bool *  to,
const Packet16b from 
)

Definition at line 792 of file SSE/PacketMath.h.

◆ pstore< double >() [1/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< double > ( double *  to,
const Packet4d from 
)

Definition at line 623 of file AVX/PacketMath.h.

◆ pstore< double >() [2/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< double > ( double *  to,
const Packet8d from 
)

Definition at line 774 of file AVX512/PacketMath.h.

◆ pstore< double >() [3/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< double > ( double *  to,
const Packet2d from 
)

Definition at line 1019 of file MSA/PacketMath.h.

◆ pstore< Eigen::half >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< Eigen::half > ( Eigen::half to,
const Packet8h from 
)

Definition at line 954 of file AVX/PacketMath.h.

◆ pstore< float >() [1/5]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< float > ( float *  to,
const Packet4f from 
)

Definition at line 491 of file AltiVec/PacketMath.h.

◆ pstore< float >() [2/5]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< float > ( float *  to,
const PacketXf &  from 
)

Definition at line 617 of file SVE/PacketMath.h.

◆ pstore< float >() [3/5]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< float > ( float *  to,
const Packet8f from 
)

Definition at line 622 of file AVX/PacketMath.h.

◆ pstore< float >() [4/5]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< float > ( float *  to,
const Packet16f from 
)

Definition at line 770 of file AVX512/PacketMath.h.

◆ pstore< float >() [5/5]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< float > ( float *  to,
const Packet2f from 
)

Definition at line 1869 of file NEON/PacketMath.h.

◆ pstore< half >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< half > ( Eigen::half to,
const Packet16h from 
)

Definition at line 1394 of file AVX512/PacketMath.h.

◆ pstore< int >() [1/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< int > ( int to,
const Packet4i from 
)

Definition at line 496 of file AltiVec/PacketMath.h.

◆ pstore< int >() [2/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< int > ( int to,
const Packet8i from 
)

Definition at line 624 of file AVX/PacketMath.h.

◆ pstore< int >() [3/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< int > ( int to,
const Packet16i from 
)

Definition at line 778 of file AVX512/PacketMath.h.

◆ pstore< int16_t >() [1/2]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< int16_t > ( int16_t to,
const Packet4s from 
)

Definition at line 1885 of file NEON/PacketMath.h.

◆ pstore< int16_t >() [2/2]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< int16_t > ( int16_t to,
const Packet8s from 
)

Definition at line 1887 of file NEON/PacketMath.h.

◆ pstore< int32_t >() [1/2]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< int32_t > ( int32_t to,
const Packet4i from 
)

Definition at line 436 of file MSA/PacketMath.h.

◆ pstore< int32_t >() [2/2]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< int32_t > ( int32_t to,
const Packet2i from 
)

Definition at line 1893 of file NEON/PacketMath.h.

◆ pstore< int64_t >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< int64_t > ( int64_t to,
const Packet2l from 
)

Definition at line 1901 of file NEON/PacketMath.h.

◆ pstore< int8_t >() [1/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< int8_t > ( int8_t to,
const Packet4c from 
)

Definition at line 1873 of file NEON/PacketMath.h.

◆ pstore< int8_t >() [2/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< int8_t > ( int8_t to,
const Packet8c from 
)

Definition at line 1875 of file NEON/PacketMath.h.

◆ pstore< int8_t >() [3/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< int8_t > ( int8_t to,
const Packet16c from 
)

Definition at line 1877 of file NEON/PacketMath.h.

◆ pstore< numext::int32_t >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< numext::int32_t > ( numext::int32_t to,
const PacketXi &  from 
)

Definition at line 251 of file SVE/PacketMath.h.

◆ pstore< short int >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< short int > ( short int to,
const Packet8s from 
)

Definition at line 501 of file AltiVec/PacketMath.h.

◆ pstore< signed char >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< signed char > ( signed char *  to,
const Packet16c from 
)

Definition at line 516 of file AltiVec/PacketMath.h.

◆ pstore< std::complex< double > >() [1/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< double > > ( std::complex< double > *  to,
const Packet4cd from 
)

Definition at line 268 of file AVX512/Complex.h.

◆ pstore< std::complex< double > >() [2/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< double > > ( std::complex< double > *  to,
const Packet2cd from 
)

Definition at line 278 of file AVX/Complex.h.

◆ pstore< std::complex< double > >() [3/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< double > > ( std::complex< double > *  to,
const Packet1cd from 
)

Definition at line 540 of file MSA/Complex.h.

◆ pstore< std::complex< float > >() [1/4]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< float > > ( std::complex< float > *  to,
const Packet8cf from 
)

Definition at line 112 of file AVX512/Complex.h.

◆ pstore< std::complex< float > >() [2/4]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< float > > ( std::complex< float > *  to,
const Packet4cf from 
)

Definition at line 113 of file AVX/Complex.h.

◆ pstore< std::complex< float > >() [3/4]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< float > > ( std::complex< float > *  to,
const Packet2cf from 
)

Definition at line 127 of file AltiVec/Complex.h.

◆ pstore< std::complex< float > >() [4/4]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< std::complex< float > > ( std::complex< float > *  to,
const Packet1cf from 
)

Definition at line 238 of file NEON/Complex.h.

◆ pstore< uint16_t >() [1/2]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< uint16_t > ( uint16_t to,
const Packet4us from 
)

Definition at line 1889 of file NEON/PacketMath.h.

◆ pstore< uint16_t >() [2/2]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< uint16_t > ( uint16_t to,
const Packet8us from 
)

Definition at line 1891 of file NEON/PacketMath.h.

◆ pstore< uint32_t >() [1/2]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< uint32_t > ( uint32_t to,
const Packet2ui from 
)

Definition at line 1897 of file NEON/PacketMath.h.

◆ pstore< uint32_t >() [2/2]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< uint32_t > ( uint32_t to,
const Packet4ui from 
)

Definition at line 1899 of file NEON/PacketMath.h.

◆ pstore< uint64_t >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< uint64_t > ( uint64_t to,
const Packet2ul from 
)

Definition at line 1903 of file NEON/PacketMath.h.

◆ pstore< uint8_t >() [1/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< uint8_t > ( uint8_t to,
const Packet4uc from 
)

Definition at line 1879 of file NEON/PacketMath.h.

◆ pstore< uint8_t >() [2/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< uint8_t > ( uint8_t to,
const Packet8uc from 
)

Definition at line 1881 of file NEON/PacketMath.h.

◆ pstore< uint8_t >() [3/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< uint8_t > ( uint8_t to,
const Packet16uc from 
)

Definition at line 1883 of file NEON/PacketMath.h.

◆ pstore< unsigned char >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< unsigned char > ( unsigned char *  to,
const Packet16uc from 
)

Definition at line 521 of file AltiVec/PacketMath.h.

◆ pstore< unsigned short int >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< unsigned short int > ( unsigned short int to,
const Packet8us from 
)

Definition at line 506 of file AltiVec/PacketMath.h.

◆ pstore_common()

template<typename Packet >
EIGEN_STRONG_INLINE void Eigen::internal::pstore_common ( __UNPACK_TYPE__(Packet) *  to,
const Packet from 
)

Definition at line 479 of file AltiVec/PacketMath.h.

◆ pstoret() [1/2]

template<typename scalar , typename packet_type , int Alignment>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void Eigen::internal::pstoret ( Eigen::TensorSycl::internal::RangeAccess< cl::sycl::access::mode::read_write, typename unpacket_traits< packet_type >::type to,
const packet_type &  from 
)

Definition at line 657 of file SYCL/PacketMath.h.

◆ pstoret() [2/2]

template<typename Scalar , typename Packet , int Alignment>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void Eigen::internal::pstoret ( Scalar to,
const Packet from 
)

Definition at line 975 of file GenericPacketMath.h.

◆ pstoreu() [1/2]

template<typename Scalar , typename Packet >
EIGEN_DEVICE_FUNC void Eigen::internal::pstoreu ( Scalar to,
const Packet from 
)
inline

Definition at line 700 of file GenericPacketMath.h.

◆ pstoreu() [2/2]

template<typename Scalar , typename Packet >
EIGEN_DEVICE_FUNC enable_if<unpacket_traits<Packet>::masked_store_available, void>::type Eigen::internal::pstoreu ( Scalar to,
const Packet from,
typename unpacket_traits< Packet >::mask_t  umask 
)
inline

◆ pstoreu< bfloat16 >() [1/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< bfloat16 > ( bfloat16 to,
const Packet8bf from 
)

Definition at line 1104 of file AltiVec/PacketMath.h.

◆ pstoreu< bfloat16 >() [2/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< bfloat16 > ( bfloat16 to,
const Packet16bf from 
)

Definition at line 1911 of file AVX512/PacketMath.h.

◆ pstoreu< bfloat16 >() [3/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< bfloat16 > ( bfloat16 to,
const Packet4bf from 
)

Definition at line 3446 of file NEON/PacketMath.h.

◆ pstoreu< bool >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< bool > ( bool *  to,
const Packet16b from 
)

Definition at line 797 of file SSE/PacketMath.h.

◆ pstoreu< double >() [1/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< double > ( double *  to,
const Packet4d from 
)

Definition at line 627 of file AVX/PacketMath.h.

◆ pstoreu< double >() [2/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< double > ( double *  to,
const Packet8d from 
)

Definition at line 788 of file AVX512/PacketMath.h.

◆ pstoreu< double >() [3/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< double > ( double *  to,
const Packet2d from 
)

Definition at line 1026 of file MSA/PacketMath.h.

◆ pstoreu< Eigen::half >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< Eigen::half > ( Eigen::half to,
const Packet8h from 
)

Definition at line 958 of file AVX/PacketMath.h.

◆ pstoreu< float >() [1/7]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float > ( float *  to,
const PacketXf &  from 
)

Definition at line 623 of file SVE/PacketMath.h.

◆ pstoreu< float >() [2/7]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float > ( float *  to,
const Packet8f from 
)

Definition at line 626 of file AVX/PacketMath.h.

◆ pstoreu< float >() [3/7]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float > ( float *  to,
const Packet8f from,
uint8_t  umask 
)

Definition at line 630 of file AVX/PacketMath.h.

◆ pstoreu< float >() [4/7]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float > ( float *  to,
const Packet16f from 
)

Definition at line 784 of file AVX512/PacketMath.h.

◆ pstoreu< float >() [5/7]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float > ( float *  to,
const Packet16f from,
uint16_t  umask 
)

Definition at line 797 of file AVX512/PacketMath.h.

◆ pstoreu< float >() [6/7]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float > ( float *  to,
const Packet4f from 
)

Definition at line 1088 of file AltiVec/PacketMath.h.

◆ pstoreu< float >() [7/7]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float > ( float *  to,
const Packet2f from 
)

Definition at line 1906 of file NEON/PacketMath.h.

◆ pstoreu< half >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< half > ( Eigen::half to,
const Packet16h from 
)

Definition at line 1400 of file AVX512/PacketMath.h.

◆ pstoreu< int >() [1/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int > ( int to,
const Packet8i from 
)

Definition at line 628 of file AVX/PacketMath.h.

◆ pstoreu< int >() [2/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int > ( int to,
const Packet16i from 
)

Definition at line 792 of file AVX512/PacketMath.h.

◆ pstoreu< int >() [3/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int > ( int to,
const Packet4i from 
)

Definition at line 1092 of file AltiVec/PacketMath.h.

◆ pstoreu< int16_t >() [1/2]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int16_t > ( int16_t to,
const Packet4s from 
)

Definition at line 1922 of file NEON/PacketMath.h.

◆ pstoreu< int16_t >() [2/2]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int16_t > ( int16_t to,
const Packet8s from 
)

Definition at line 1924 of file NEON/PacketMath.h.

◆ pstoreu< int32_t >() [1/2]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int32_t > ( int32_t to,
const Packet4i from 
)

Definition at line 450 of file MSA/PacketMath.h.

◆ pstoreu< int32_t >() [2/2]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int32_t > ( int32_t to,
const Packet2i from 
)

Definition at line 1930 of file NEON/PacketMath.h.

◆ pstoreu< int64_t >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int64_t > ( int64_t to,
const Packet2l from 
)

Definition at line 1938 of file NEON/PacketMath.h.

◆ pstoreu< int8_t >() [1/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int8_t > ( int8_t to,
const Packet4c from 
)

Definition at line 1910 of file NEON/PacketMath.h.

◆ pstoreu< int8_t >() [2/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int8_t > ( int8_t to,
const Packet8c from 
)

Definition at line 1912 of file NEON/PacketMath.h.

◆ pstoreu< int8_t >() [3/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int8_t > ( int8_t to,
const Packet16c from 
)

Definition at line 1914 of file NEON/PacketMath.h.

◆ pstoreu< numext::int32_t >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< numext::int32_t > ( numext::int32_t to,
const PacketXi &  from 
)

Definition at line 257 of file SVE/PacketMath.h.

◆ pstoreu< short int >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< short int > ( short int to,
const Packet8s from 
)

Definition at line 1096 of file AltiVec/PacketMath.h.

◆ pstoreu< signed char >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< signed char > ( signed char *  to,
const Packet16c from 
)

Definition at line 1108 of file AltiVec/PacketMath.h.

◆ pstoreu< std::complex< double > >() [1/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< double > > ( std::complex< double > *  to,
const Packet4cd from 
)

Definition at line 269 of file AVX512/Complex.h.

◆ pstoreu< std::complex< double > >() [2/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< double > > ( std::complex< double > *  to,
const Packet2cd from 
)

Definition at line 279 of file AVX/Complex.h.

◆ pstoreu< std::complex< double > >() [3/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< double > > ( std::complex< double > *  to,
const Packet1cd from 
)

Definition at line 548 of file MSA/Complex.h.

◆ pstoreu< std::complex< float > >() [1/4]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< float > > ( std::complex< float > *  to,
const Packet8cf from 
)

Definition at line 113 of file AVX512/Complex.h.

◆ pstoreu< std::complex< float > >() [2/4]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< float > > ( std::complex< float > *  to,
const Packet4cf from 
)

Definition at line 114 of file AVX/Complex.h.

◆ pstoreu< std::complex< float > >() [3/4]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< float > > ( std::complex< float > *  to,
const Packet2cf from 
)

Definition at line 128 of file AltiVec/Complex.h.

◆ pstoreu< std::complex< float > >() [4/4]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< std::complex< float > > ( std::complex< float > *  to,
const Packet1cf from 
)

Definition at line 243 of file NEON/Complex.h.

◆ pstoreu< uint16_t >() [1/2]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< uint16_t > ( uint16_t to,
const Packet4us from 
)

Definition at line 1926 of file NEON/PacketMath.h.

◆ pstoreu< uint16_t >() [2/2]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< uint16_t > ( uint16_t to,
const Packet8us from 
)

Definition at line 1928 of file NEON/PacketMath.h.

◆ pstoreu< uint32_t >() [1/2]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< uint32_t > ( uint32_t to,
const Packet2ui from 
)

Definition at line 1934 of file NEON/PacketMath.h.

◆ pstoreu< uint32_t >() [2/2]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< uint32_t > ( uint32_t to,
const Packet4ui from 
)

Definition at line 1936 of file NEON/PacketMath.h.

◆ pstoreu< uint64_t >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< uint64_t > ( uint64_t to,
const Packet2ul from 
)

Definition at line 1940 of file NEON/PacketMath.h.

◆ pstoreu< uint8_t >() [1/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< uint8_t > ( uint8_t to,
const Packet4uc from 
)

Definition at line 1916 of file NEON/PacketMath.h.

◆ pstoreu< uint8_t >() [2/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< uint8_t > ( uint8_t to,
const Packet8uc from 
)

Definition at line 1918 of file NEON/PacketMath.h.

◆ pstoreu< uint8_t >() [3/3]

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< uint8_t > ( uint8_t to,
const Packet16uc from 
)

Definition at line 1920 of file NEON/PacketMath.h.

◆ pstoreu< unsigned char >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< unsigned char > ( unsigned char *  to,
const Packet16uc from 
)

Definition at line 1112 of file AltiVec/PacketMath.h.

◆ pstoreu< unsigned short int >()

template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< unsigned short int > ( unsigned short int to,
const Packet8us from 
)

Definition at line 1100 of file AltiVec/PacketMath.h.

◆ pstoreu_common()

template<typename Packet >
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu_common ( __UNPACK_TYPE__(Packet) *  to,
const Packet from 
)

Definition at line 1066 of file AltiVec/PacketMath.h.

◆ psub()

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::psub ( const Packet a,
const Packet b 
)
inline

Definition at line 222 of file GenericPacketMath.h.

◆ psub< Packet16b >()

template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::psub< Packet16b > ( const Packet16b a,
const Packet16b b 
)

Definition at line 298 of file SSE/PacketMath.h.

◆ psub< Packet16bf >()

Definition at line 2079 of file AVX512/PacketMath.h.

◆ psub< Packet16c >()

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::psub< Packet16c > ( const Packet16c a,
const Packet16c b 
)

Definition at line 786 of file AltiVec/PacketMath.h.

◆ psub< Packet16f >()

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::psub< Packet16f > ( const Packet16f a,
const Packet16f b 
)

Definition at line 275 of file AVX512/PacketMath.h.

◆ psub< Packet16h >()

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::psub< Packet16h > ( const Packet16h a,
const Packet16h b 
)

Definition at line 1579 of file AVX512/PacketMath.h.

◆ psub< Packet16i >()

template<>
EIGEN_STRONG_INLINE Packet16i Eigen::internal::psub< Packet16i > ( const Packet16i a,
const Packet16i b 
)

Definition at line 285 of file AVX512/PacketMath.h.

◆ psub< Packet16uc >()

Definition at line 787 of file AltiVec/PacketMath.h.

◆ psub< Packet1cd >()

template<>
EIGEN_STRONG_INLINE Packet1cd Eigen::internal::psub< Packet1cd > ( const Packet1cd a,
const Packet1cd b 
)

Definition at line 477 of file MSA/Complex.h.

◆ psub< Packet1cf >()

template<>
EIGEN_STRONG_INLINE Packet1cf Eigen::internal::psub< Packet1cf > ( const Packet1cf a,
const Packet1cf b 
)

Definition at line 122 of file NEON/Complex.h.

◆ psub< Packet2cd >()

template<>
EIGEN_STRONG_INLINE Packet2cd Eigen::internal::psub< Packet2cd > ( const Packet2cd a,
const Packet2cd b 
)

Definition at line 234 of file AVX/Complex.h.

◆ psub< Packet2cf >()

template<>
EIGEN_STRONG_INLINE Packet2cf Eigen::internal::psub< Packet2cf > ( const Packet2cf a,
const Packet2cf b 
)

Definition at line 165 of file AltiVec/Complex.h.

◆ psub< Packet2d >()

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::psub< Packet2d > ( const Packet2d a,
const Packet2d b 
)

Definition at line 895 of file MSA/PacketMath.h.

◆ psub< Packet2f >()

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::psub< Packet2f > ( const Packet2f a,
const Packet2f b 
)

Definition at line 834 of file NEON/PacketMath.h.

◆ psub< Packet2i >()

template<>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::psub< Packet2i > ( const Packet2i a,
const Packet2i b 
)

Definition at line 856 of file NEON/PacketMath.h.

◆ psub< Packet2l >()

template<>
EIGEN_STRONG_INLINE Packet2l Eigen::internal::psub< Packet2l > ( const Packet2l a,
const Packet2l b 
)

Definition at line 860 of file NEON/PacketMath.h.

◆ psub< Packet2ui >()

template<>
EIGEN_STRONG_INLINE Packet2ui Eigen::internal::psub< Packet2ui > ( const Packet2ui a,
const Packet2ui b 
)

Definition at line 858 of file NEON/PacketMath.h.

◆ psub< Packet2ul >()

template<>
EIGEN_STRONG_INLINE Packet2ul Eigen::internal::psub< Packet2ul > ( const Packet2ul a,
const Packet2ul b 
)

Definition at line 861 of file NEON/PacketMath.h.

◆ psub< Packet4bf >()

template<>
EIGEN_STRONG_INLINE Packet4bf Eigen::internal::psub< Packet4bf > ( const Packet4bf a,
const Packet4bf b 
)

Definition at line 3542 of file NEON/PacketMath.h.

◆ psub< Packet4c >()

template<>
EIGEN_STRONG_INLINE Packet4c Eigen::internal::psub< Packet4c > ( const Packet4c a,
const Packet4c b 
)

Definition at line 836 of file NEON/PacketMath.h.

◆ psub< Packet4cd >()

template<>
EIGEN_STRONG_INLINE Packet4cd Eigen::internal::psub< Packet4cd > ( const Packet4cd a,
const Packet4cd b 
)

Definition at line 218 of file AVX512/Complex.h.

◆ psub< Packet4cf >()

template<>
EIGEN_STRONG_INLINE Packet4cf Eigen::internal::psub< Packet4cf > ( const Packet4cf a,
const Packet4cf b 
)

Definition at line 65 of file AVX/Complex.h.

◆ psub< Packet4d >()

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::psub< Packet4d > ( const Packet4d a,
const Packet4d b 
)

Definition at line 275 of file AVX/PacketMath.h.

◆ psub< Packet4f >()

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::psub< Packet4f > ( const Packet4f a,
const Packet4f b 
)

Definition at line 782 of file AltiVec/PacketMath.h.

◆ psub< Packet4i >()

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::psub< Packet4i > ( const Packet4i a,
const Packet4i b 
)

Definition at line 783 of file AltiVec/PacketMath.h.

◆ psub< Packet4s >()

template<>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::psub< Packet4s > ( const Packet4s a,
const Packet4s b 
)

Definition at line 852 of file NEON/PacketMath.h.

◆ psub< Packet4uc >()

template<>
EIGEN_STRONG_INLINE Packet4uc Eigen::internal::psub< Packet4uc > ( const Packet4uc a,
const Packet4uc b 
)

Definition at line 844 of file NEON/PacketMath.h.

◆ psub< Packet4ui >()

template<>
EIGEN_STRONG_INLINE Packet4ui Eigen::internal::psub< Packet4ui > ( const Packet4ui a,
const Packet4ui b 
)

Definition at line 859 of file NEON/PacketMath.h.

◆ psub< Packet4us >()

template<>
EIGEN_STRONG_INLINE Packet4us Eigen::internal::psub< Packet4us > ( const Packet4us a,
const Packet4us b 
)

Definition at line 854 of file NEON/PacketMath.h.

◆ psub< Packet8bf >()

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::psub< Packet8bf > ( const Packet8bf a,
const Packet8bf b 
)

Definition at line 1340 of file AltiVec/PacketMath.h.

◆ psub< Packet8c >()

template<>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::psub< Packet8c > ( const Packet8c a,
const Packet8c b 
)

Definition at line 842 of file NEON/PacketMath.h.

◆ psub< Packet8cf >()

template<>
EIGEN_STRONG_INLINE Packet8cf Eigen::internal::psub< Packet8cf > ( const Packet8cf a,
const Packet8cf b 
)

Definition at line 64 of file AVX512/Complex.h.

◆ psub< Packet8d >()

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::psub< Packet8d > ( const Packet8d a,
const Packet8d b 
)

Definition at line 280 of file AVX512/PacketMath.h.

◆ psub< Packet8f >()

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::psub< Packet8f > ( const Packet8f a,
const Packet8f b 
)

Definition at line 274 of file AVX/PacketMath.h.

◆ psub< Packet8h >()

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::psub< Packet8h > ( const Packet8h a,
const Packet8h b 
)

Definition at line 1107 of file AVX/PacketMath.h.

◆ psub< Packet8i >()

template<>
EIGEN_STRONG_INLINE Packet8i Eigen::internal::psub< Packet8i > ( const Packet8i a,
const Packet8i b 
)

Definition at line 276 of file AVX/PacketMath.h.

◆ psub< Packet8s >()

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::psub< Packet8s > ( const Packet8s a,
const Packet8s b 
)

Definition at line 784 of file AltiVec/PacketMath.h.

◆ psub< Packet8uc >()

template<>
EIGEN_STRONG_INLINE Packet8uc Eigen::internal::psub< Packet8uc > ( const Packet8uc a,
const Packet8uc b 
)

Definition at line 850 of file NEON/PacketMath.h.

◆ psub< Packet8us >()

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::psub< Packet8us > ( const Packet8us a,
const Packet8us b 
)

Definition at line 785 of file AltiVec/PacketMath.h.

◆ psub< PacketXf >()

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

Definition at line 450 of file SVE/PacketMath.h.

◆ psub< PacketXi >()

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

Definition at line 102 of file SVE/PacketMath.h.

◆ ptan()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::ptan ( const Packet a)

Definition at line 760 of file GenericPacketMath.h.

◆ ptanh()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::ptanh ( const Packet a)

Definition at line 784 of file GenericPacketMath.h.

◆ ptanh< Packet16f >()

Definition at line 346 of file Eigen/src/Core/arch/AVX512/MathFunctions.h.

◆ ptanh< Packet2f >()

Definition at line 36 of file Eigen/src/Core/arch/NEON/MathFunctions.h.

◆ ptanh< Packet4f >()

Definition at line 82 of file Eigen/src/Core/arch/AltiVec/MathFunctions.h.

◆ ptanh< Packet8f >()

Definition at line 79 of file Eigen/src/Core/arch/AVX/MathFunctions.h.

◆ ptanh< PacketXf >()

template<>
EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf Eigen::internal::ptanh< PacketXf > ( const PacketXf &  x)

Definition at line 38 of file Eigen/src/Core/arch/SVE/MathFunctions.h.

◆ ptranpose_common()

template<typename T >
EIGEN_DEVICE_FUNC void Eigen::internal::ptranpose_common ( PacketBlock< T, 4 > &  kernel)
inline

Definition at line 1771 of file AltiVec/PacketMath.h.

◆ ptranspose() [1/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet2cf, 2 > &  kernel)
inline

Definition at line 224 of file AltiVec/Complex.h.

◆ ptranspose() [2/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet4cf, 4 > &  kernel)
inline

Definition at line 336 of file AVX/Complex.h.

◆ ptranspose() [3/57]

template<int N>
EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< PacketXi, N > &  kernel)
inline

Definition at line 351 of file SVE/PacketMath.h.

◆ ptranspose() [4/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet2cd, 2 > &  kernel)
inline

Definition at line 354 of file AVX/Complex.h.

◆ ptranspose() [5/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet8cf, 4 > &  kernel)
inline

Definition at line 361 of file AVX512/Complex.h.

◆ ptranspose() [6/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet1cf, 1 > &  )
inline

Definition at line 373 of file NEON/Complex.h.

◆ ptranspose() [7/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet8cf, 8 > &  kernel)
inline

Definition at line 376 of file AVX512/Complex.h.

◆ ptranspose() [8/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet4cd, 4 > &  kernel)
inline

Definition at line 399 of file AVX512/Complex.h.

◆ ptranspose() [9/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet1cd, 2 > &  kernel)

Definition at line 631 of file MSA/Complex.h.

◆ ptranspose() [10/57]

template<int N>
EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< PacketXf, N > &  kernel)
inline

Definition at line 727 of file SVE/PacketMath.h.

◆ ptranspose() [11/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet8f, 8 > &  kernel)
inline

Definition at line 863 of file AVX/PacketMath.h.

◆ ptranspose() [12/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet8f, 4 > &  kernel)
inline

Definition at line 891 of file AVX/PacketMath.h.

◆ ptranspose() [13/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet4d, 4 > &  kernel)
inline

Definition at line 909 of file AVX/PacketMath.h.

◆ ptranspose() [14/57]

template<typename Packet >
EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet, 1 > &  )
inline

Definition at line 1019 of file GenericPacketMath.h.

◆ ptranspose() [15/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet16f, 16 > &  kernel)
inline

Definition at line 1107 of file AVX512/PacketMath.h.

◆ ptranspose() [16/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet16b, 4 > &  kernel)
inline

Definition at line 1149 of file SSE/PacketMath.h.

◆ ptranspose() [17/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet2d, 2 > &  kernel)
inline

Definition at line 1153 of file MSA/PacketMath.h.

◆ ptranspose() [18/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet16b, 16 > &  kernel)
inline

Definition at line 1161 of file SSE/PacketMath.h.

◆ ptranspose() [19/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8h, 8 > &  kernel)

Definition at line 1186 of file AVX/PacketMath.h.

◆ ptranspose() [20/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet16f, 4 > &  kernel)
inline

Definition at line 1222 of file AVX512/PacketMath.h.

◆ ptranspose() [21/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8h, 4 > &  kernel)

Definition at line 1234 of file AVX/PacketMath.h.

◆ ptranspose() [22/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet8d, 4 > &  kernel)
inline

Definition at line 1265 of file AVX512/PacketMath.h.

◆ ptranspose() [23/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet8d, 8 > &  kernel)
inline

Definition at line 1297 of file AVX512/PacketMath.h.

◆ ptranspose() [24/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet16h, 16 > &  kernel)

Definition at line 1669 of file AVX512/PacketMath.h.

◆ ptranspose() [25/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet16h, 8 > &  kernel)

Definition at line 1777 of file AVX512/PacketMath.h.

◆ ptranspose() [26/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet4f, 4 > &  kernel)
inline

Definition at line 1784 of file AltiVec/PacketMath.h.

◆ ptranspose() [27/57]

EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose ( PacketBlock< Packet4i, 4 > &  kernel)
inline

Definition at line 1789 of file AltiVec/PacketMath.h.

◆ ptranspose() [28/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8s, 4 > &  kernel)
inline

Definition at line 1794 of file AltiVec/PacketMath.h.

◆ ptranspose() [29/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8us, 4 > &  kernel)
inline

Definition at line 1807 of file AltiVec/PacketMath.h.

◆ ptranspose() [30/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet16h, 4 > &  kernel)

Definition at line 1810 of file AVX512/PacketMath.h.

◆ ptranspose() [31/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8bf, 4 > &  kernel)
inline

Definition at line 1821 of file AltiVec/PacketMath.h.

◆ ptranspose() [32/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet16c, 4 > &  kernel)
inline

Definition at line 1835 of file AltiVec/PacketMath.h.

◆ ptranspose() [33/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet16uc, 4 > &  kernel)
inline

Definition at line 1849 of file AltiVec/PacketMath.h.

◆ ptranspose() [34/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8s, 8 > &  kernel)
inline

Definition at line 1862 of file AltiVec/PacketMath.h.

◆ ptranspose() [35/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8us, 8 > &  kernel)
inline

Definition at line 1893 of file AltiVec/PacketMath.h.

◆ ptranspose() [36/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8bf, 8 > &  kernel)
inline

Definition at line 1924 of file AltiVec/PacketMath.h.

◆ ptranspose() [37/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet16c, 16 > &  kernel)
inline

Definition at line 1955 of file AltiVec/PacketMath.h.

◆ ptranspose() [38/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet16uc, 16 > &  kernel)
inline

Definition at line 2028 of file AltiVec/PacketMath.h.

◆ ptranspose() [39/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet16bf, 16 > &  kernel)

Definition at line 2186 of file AVX512/PacketMath.h.

◆ ptranspose() [40/57]

EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet16bf, 4 > &  kernel)

Definition at line 2276 of file AVX512/PacketMath.h.

◆ ptranspose() [41/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet2f, 2 > &  kernel)

Definition at line 2927 of file NEON/PacketMath.h.

◆ ptranspose() [42/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet4c, 4 > &  kernel)

Definition at line 2934 of file NEON/PacketMath.h.

◆ ptranspose() [43/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8c, 8 > &  kernel)

Definition at line 2947 of file NEON/PacketMath.h.

◆ ptranspose() [44/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8c, 4 > &  kernel)

Definition at line 2950 of file NEON/PacketMath.h.

◆ ptranspose() [45/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet16c, 8 > &  kernel)

Definition at line 2956 of file NEON/PacketMath.h.

◆ ptranspose() [46/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet4uc, 4 > &  kernel)

Definition at line 2963 of file NEON/PacketMath.h.

◆ ptranspose() [47/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8uc, 8 > &  kernel)

Definition at line 2976 of file NEON/PacketMath.h.

◆ ptranspose() [48/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet8uc, 4 > &  kernel)

Definition at line 2979 of file NEON/PacketMath.h.

◆ ptranspose() [49/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet16uc, 8 > &  kernel)

Definition at line 2985 of file NEON/PacketMath.h.

◆ ptranspose() [50/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet4s, 4 > &  kernel)

Definition at line 2992 of file NEON/PacketMath.h.

◆ ptranspose() [51/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet4us, 4 > &  kernel)

Definition at line 3002 of file NEON/PacketMath.h.

◆ ptranspose() [52/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet2i, 2 > &  kernel)

Definition at line 3012 of file NEON/PacketMath.h.

◆ ptranspose() [53/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet2ui, 2 > &  kernel)

Definition at line 3018 of file NEON/PacketMath.h.

◆ ptranspose() [54/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet4ui, 4 > &  kernel)

Definition at line 3021 of file NEON/PacketMath.h.

◆ ptranspose() [55/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet2l, 2 > &  kernel)

Definition at line 3026 of file NEON/PacketMath.h.

◆ ptranspose() [56/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet2ul, 2 > &  kernel)

Definition at line 3043 of file NEON/PacketMath.h.

◆ ptranspose() [57/57]

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::ptranspose ( PacketBlock< Packet4bf, 4 > &  kernel)

Definition at line 3591 of file NEON/PacketMath.h.

◆ ptrue() [1/5]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::ptrue ( const Packet a)
inline

Definition at line 270 of file GenericPacketMath.h.

◆ ptrue() [2/5]

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::ptrue ( const Packet8h a)

Definition at line 978 of file AVX/PacketMath.h.

◆ ptrue() [3/5]

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::ptrue ( const Packet8bf a)

Definition at line 1363 of file AVX/PacketMath.h.

◆ ptrue() [4/5]

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::ptrue ( const Packet16h a)

Definition at line 1485 of file AVX512/PacketMath.h.

◆ ptrue() [5/5]

template<>
EIGEN_STRONG_INLINE Packet16bf Eigen::internal::ptrue ( const Packet16bf a)

Definition at line 1980 of file AVX512/PacketMath.h.

◆ ptrue< Packet16b >()

Definition at line 399 of file SSE/PacketMath.h.

◆ ptrue< Packet16f >()

Definition at line 541 of file AVX512/PacketMath.h.

◆ ptrue< Packet16i >()

Definition at line 536 of file AVX512/PacketMath.h.

◆ ptrue< Packet1cd >()

Definition at line 257 of file SSE/Complex.h.

◆ ptrue< Packet2cd >()

Definition at line 258 of file AVX/Complex.h.

◆ ptrue< Packet2cf >()

Definition at line 98 of file SSE/Complex.h.

◆ ptrue< Packet2d >()

Definition at line 406 of file SSE/PacketMath.h.

◆ ptrue< Packet4cd >()

Definition at line 237 of file AVX512/Complex.h.

◆ ptrue< Packet4cf >()

Definition at line 90 of file AVX/Complex.h.

◆ ptrue< Packet4d >()

Definition at line 479 of file AVX/PacketMath.h.

◆ ptrue< Packet4f >()

Definition at line 401 of file SSE/PacketMath.h.

◆ ptrue< Packet4i >()

Definition at line 398 of file SSE/PacketMath.h.

◆ ptrue< Packet8cf >()

Definition at line 62 of file AVX512/Complex.h.

◆ ptrue< Packet8d >()

Definition at line 546 of file AVX512/PacketMath.h.

◆ ptrue< Packet8f >()

Definition at line 469 of file AVX/PacketMath.h.

◆ ptrue< Packet8i >()

Definition at line 459 of file AVX/PacketMath.h.

◆ ptrue< PacketXf >()

template<>
EIGEN_STRONG_INLINE PacketXf Eigen::internal::ptrue< PacketXf > ( const PacketXf &  )

Definition at line 557 of file SVE/PacketMath.h.

◆ ptrue< PacketXi >()

template<>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::ptrue< PacketXi > ( const PacketXi &  )

Definition at line 168 of file SVE/PacketMath.h.

◆ punpackp()

EIGEN_STRONG_INLINE void Eigen::internal::punpackp ( Packet4f vecs)

Definition at line 979 of file SSE/PacketMath.h.

◆ putMarketHeader()

template<typename Scalar >
void Eigen::internal::putMarketHeader ( std::string &  header,
int  sym 
)
inline

Definition at line 66 of file MarketIO.h.

◆ PutMatrixElt() [1/2]

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

Definition at line 85 of file MarketIO.h.

◆ PutMatrixElt() [2/2]

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

Definition at line 90 of file MarketIO.h.

◆ putVectorElt() [1/2]

template<typename Scalar >
void Eigen::internal::putVectorElt ( Scalar  value,
std::ofstream &  out 
)
inline

Definition at line 97 of file MarketIO.h.

◆ putVectorElt() [2/2]

template<typename Scalar >
void Eigen::internal::putVectorElt ( std::complex< Scalar value,
std::ofstream &  out 
)
inline

Definition at line 102 of file MarketIO.h.

◆ pxor() [1/6]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pxor ( const Packet a,
const Packet b 
)
inline

Definition at line 419 of file GenericPacketMath.h.

◆ pxor() [2/6]

template<>
EIGEN_STRONG_INLINE Packet8h Eigen::internal::pxor ( const Packet8h a,
const Packet8h b 
)

Definition at line 1047 of file AVX/PacketMath.h.

◆ pxor() [3/6]

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pxor ( const Packet8bf a,
const Packet8bf b 
)

Definition at line 1393 of file AVX/PacketMath.h.

◆ pxor() [4/6]

template<>
EIGEN_STRONG_INLINE Packet16h Eigen::internal::pxor ( const Packet16h a,
const Packet16h b 
)

Definition at line 1517 of file AVX512/PacketMath.h.

◆ pxor() [5/6]

template<>
EIGEN_STRONG_INLINE Packet16bf Eigen::internal::pxor ( const Packet16bf a,
const Packet16bf b 
)

Definition at line 1990 of file AVX512/PacketMath.h.

◆ pxor() [6/6]

template<>
EIGEN_STRONG_INLINE Packet4bf Eigen::internal::pxor ( const Packet4bf a,
const Packet4bf b 
)

Definition at line 3503 of file NEON/PacketMath.h.

◆ pxor< Packet16b >()

template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::pxor< Packet16b > ( const Packet16b a,
const Packet16b b 
)

Definition at line 425 of file SSE/PacketMath.h.

◆ pxor< Packet16c >()

template<>
EIGEN_STRONG_INLINE Packet16c Eigen::internal::pxor< Packet16c > ( const Packet16c a,
const Packet16c b 
)

Definition at line 1539 of file NEON/PacketMath.h.

◆ pxor< Packet16f >()

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pxor< Packet16f > ( const Packet16f a,
const Packet16f b 
)

Definition at line 612 of file AVX512/PacketMath.h.

◆ pxor< Packet16i >()

template<>
EIGEN_STRONG_INLINE Packet16i Eigen::internal::pxor< Packet16i > ( const Packet16i a,
const Packet16i b 
)

Definition at line 607 of file AVX512/PacketMath.h.

◆ pxor< Packet16uc >()

Definition at line 1545 of file NEON/PacketMath.h.

◆ pxor< Packet1cd >()

template<>
EIGEN_STRONG_INLINE Packet1cd Eigen::internal::pxor< Packet1cd > ( const Packet1cd a,
const Packet1cd b 
)

Definition at line 519 of file MSA/Complex.h.

◆ pxor< Packet1cf >()

template<>
EIGEN_STRONG_INLINE Packet1cf Eigen::internal::pxor< Packet1cf > ( const Packet1cf a,
const Packet1cf b 
)

Definition at line 213 of file NEON/Complex.h.

◆ pxor< Packet2cd >()

template<>
EIGEN_STRONG_INLINE Packet2cd Eigen::internal::pxor< Packet2cd > ( const Packet2cd a,
const Packet2cd b 
)

Definition at line 261 of file AVX/Complex.h.

◆ pxor< Packet2cf >()

template<>
EIGEN_STRONG_INLINE Packet2cf Eigen::internal::pxor< Packet2cf > ( const Packet2cf a,
const Packet2cf b 
)

Definition at line 171 of file AltiVec/Complex.h.

◆ pxor< Packet2d >()

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pxor< Packet2d > ( const Packet2d a,
const Packet2d b 
)

Definition at line 953 of file MSA/PacketMath.h.

◆ pxor< Packet2f >()

template<>
EIGEN_STRONG_INLINE Packet2f Eigen::internal::pxor< Packet2f > ( const Packet2f a,
const Packet2f b 
)

Definition at line 1531 of file NEON/PacketMath.h.

◆ pxor< Packet2i >()

template<>
EIGEN_STRONG_INLINE Packet2i Eigen::internal::pxor< Packet2i > ( const Packet2i a,
const Packet2i b 
)

Definition at line 1553 of file NEON/PacketMath.h.

◆ pxor< Packet2l >()

template<>
EIGEN_STRONG_INLINE Packet2l Eigen::internal::pxor< Packet2l > ( const Packet2l a,
const Packet2l b 
)

Definition at line 1559 of file NEON/PacketMath.h.

◆ pxor< Packet2ui >()

template<>
EIGEN_STRONG_INLINE Packet2ui Eigen::internal::pxor< Packet2ui > ( const Packet2ui a,
const Packet2ui b 
)

Definition at line 1555 of file NEON/PacketMath.h.

◆ pxor< Packet2ul >()

template<>
EIGEN_STRONG_INLINE Packet2ul Eigen::internal::pxor< Packet2ul > ( const Packet2ul a,
const Packet2ul b 
)

Definition at line 1561 of file NEON/PacketMath.h.

◆ pxor< Packet4c >()

template<>
EIGEN_STRONG_INLINE Packet4c Eigen::internal::pxor< Packet4c > ( const Packet4c a,
const Packet4c b 
)

Definition at line 1535 of file NEON/PacketMath.h.

◆ pxor< Packet4cd >()

template<>
EIGEN_STRONG_INLINE Packet4cd Eigen::internal::pxor< Packet4cd > ( const Packet4cd a,
const Packet4cd b 
)

Definition at line 240 of file AVX512/Complex.h.

◆ pxor< Packet4cf >()

template<>
EIGEN_STRONG_INLINE Packet4cf Eigen::internal::pxor< Packet4cf > ( const Packet4cf a,
const Packet4cf b 
)

Definition at line 93 of file AVX/Complex.h.

◆ pxor< Packet4d >()

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pxor< Packet4d > ( const Packet4d a,
const Packet4d b 
)

Definition at line 510 of file AVX/PacketMath.h.

◆ pxor< Packet4f >()

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pxor< Packet4f > ( const Packet4f a,
const Packet4f b 
)

Definition at line 908 of file AltiVec/PacketMath.h.

◆ pxor< Packet4i >()

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pxor< Packet4i > ( const Packet4i a,
const Packet4i b 
)

Definition at line 909 of file AltiVec/PacketMath.h.

◆ pxor< Packet4s >()

template<>
EIGEN_STRONG_INLINE Packet4s Eigen::internal::pxor< Packet4s > ( const Packet4s a,
const Packet4s b 
)

Definition at line 1547 of file NEON/PacketMath.h.

◆ pxor< Packet4uc >()

template<>
EIGEN_STRONG_INLINE Packet4uc Eigen::internal::pxor< Packet4uc > ( const Packet4uc a,
const Packet4uc b 
)

Definition at line 1541 of file NEON/PacketMath.h.

◆ pxor< Packet4ui >()

template<>
EIGEN_STRONG_INLINE Packet4ui Eigen::internal::pxor< Packet4ui > ( const Packet4ui a,
const Packet4ui b 
)

Definition at line 1557 of file NEON/PacketMath.h.

◆ pxor< Packet4us >()

template<>
EIGEN_STRONG_INLINE Packet4us Eigen::internal::pxor< Packet4us > ( const Packet4us a,
const Packet4us b 
)

Definition at line 1549 of file NEON/PacketMath.h.

◆ pxor< Packet8bf >()

template<>
EIGEN_STRONG_INLINE Packet8bf Eigen::internal::pxor< Packet8bf > ( const Packet8bf a,
const Packet8bf b 
)

Definition at line 910 of file AltiVec/PacketMath.h.

◆ pxor< Packet8c >()

template<>
EIGEN_STRONG_INLINE Packet8c Eigen::internal::pxor< Packet8c > ( const Packet8c a,
const Packet8c b 
)

Definition at line 1537 of file NEON/PacketMath.h.

◆ pxor< Packet8cf >()

template<>
EIGEN_STRONG_INLINE Packet8cf Eigen::internal::pxor< Packet8cf > ( const Packet8cf a,
const Packet8cf b 
)

Definition at line 85 of file AVX512/Complex.h.

◆ pxor< Packet8d >()

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pxor< Packet8d > ( const Packet8d a,
const Packet8d b 
)

Definition at line 621 of file AVX512/PacketMath.h.

◆ pxor< Packet8f >()

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pxor< Packet8f > ( const Packet8f a,
const Packet8f b 
)

Definition at line 509 of file AVX/PacketMath.h.

◆ pxor< Packet8i >()

template<>
EIGEN_STRONG_INLINE Packet8i Eigen::internal::pxor< Packet8i > ( const Packet8i a,
const Packet8i b 
)

Definition at line 511 of file AVX/PacketMath.h.

◆ pxor< Packet8s >()

template<>
EIGEN_STRONG_INLINE Packet8s Eigen::internal::pxor< Packet8s > ( const Packet8s a,
const Packet8s b 
)

Definition at line 1548 of file NEON/PacketMath.h.

◆ pxor< Packet8uc >()

template<>
EIGEN_STRONG_INLINE Packet8uc Eigen::internal::pxor< Packet8uc > ( const Packet8uc a,
const Packet8uc b 
)

Definition at line 1543 of file NEON/PacketMath.h.

◆ pxor< Packet8us >()

template<>
EIGEN_STRONG_INLINE Packet8us Eigen::internal::pxor< Packet8us > ( const Packet8us a,
const Packet8us b 
)

Definition at line 1551 of file NEON/PacketMath.h.

◆ pxor< PacketXf >()

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

Definition at line 576 of file SVE/PacketMath.h.

◆ pxor< PacketXi >()

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

Definition at line 192 of file SVE/PacketMath.h.

◆ pzero() [1/10]

template<>
EIGEN_STRONG_INLINE Packet16f Eigen::internal::pzero ( const Packet16f )

Definition at line 219 of file AVX512/PacketMath.h.

◆ pzero() [2/10]

template<>
EIGEN_STRONG_INLINE Packet8d Eigen::internal::pzero ( const Packet8d )

Definition at line 220 of file AVX512/PacketMath.h.

◆ pzero() [3/10]

template<>
EIGEN_STRONG_INLINE Packet16i Eigen::internal::pzero ( const Packet16i )

Definition at line 221 of file AVX512/PacketMath.h.

◆ pzero() [4/10]

template<>
EIGEN_STRONG_INLINE Packet8f Eigen::internal::pzero ( const Packet8f )

Definition at line 247 of file AVX/PacketMath.h.

◆ pzero() [5/10]

template<>
EIGEN_STRONG_INLINE Packet4d Eigen::internal::pzero ( const Packet4d )

Definition at line 248 of file AVX/PacketMath.h.

◆ pzero() [6/10]

template<>
EIGEN_STRONG_INLINE Packet8i Eigen::internal::pzero ( const Packet8i )

Definition at line 249 of file AVX/PacketMath.h.

◆ pzero() [7/10]

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pzero ( const Packet4f )

Definition at line 270 of file SSE/PacketMath.h.

◆ pzero() [8/10]

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pzero ( const Packet2d )

Definition at line 271 of file SSE/PacketMath.h.

◆ pzero() [9/10]

template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pzero ( const Packet4i )

Definition at line 272 of file SSE/PacketMath.h.

◆ pzero() [10/10]

template<typename Packet >
EIGEN_DEVICE_FUNC Packet Eigen::internal::pzero ( const Packet a)
inline

Definition at line 296 of file GenericPacketMath.h.

◆ pzero< PacketXi >()

template<>
EIGEN_STRONG_INLINE PacketXi Eigen::internal::pzero< PacketXi > ( const PacketXi &  )

Definition at line 174 of file SVE/PacketMath.h.

◆ pzeta()

template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pzeta ( const Packet x,
const Packet q 
)

Definition at line 27 of file SpecialFunctionsPacketMath.h.

◆ qrsolv()

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

Definition at line 7 of file qrsolv.h.

◆ queryCacheSizes()

void Eigen::internal::queryCacheSizes ( int l1,
int l2,
int l3 
)
inline

Definition at line 1106 of file Memory.h.

◆ queryL1CacheSize()

int Eigen::internal::queryL1CacheSize ( )
inline

Definition at line 1143 of file Memory.h.

◆ queryTopLevelCacheSize()

int Eigen::internal::queryTopLevelCacheSize ( )
inline

Definition at line 1152 of file Memory.h.

◆ QuickSplit()

template<typename VectorV , typename VectorI >
Index Eigen::internal::QuickSplit ( VectorV &  row,
VectorI &  ind,
Index  ncut 
)

Definition at line 29 of file IncompleteLUT.h.

◆ r1mpyq()

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

Definition at line 8 of file r1mpyq.h.

◆ r1updt()

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

Definition at line 6 of file r1updt.h.

◆ RandomToTypeNormal()

template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T Eigen::internal::RandomToTypeNormal ( uint64_t state,
uint64_t  stream 
)

Definition at line 209 of file TensorRandom.h.

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

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<double> Eigen::internal::RandomToTypeNormal< std::complex< double > > ( uint64_t state,
uint64_t  stream 
)

Definition at line 232 of file TensorRandom.h.

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

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<float> Eigen::internal::RandomToTypeNormal< std::complex< float > > ( uint64_t state,
uint64_t  stream 
)

Definition at line 227 of file TensorRandom.h.

◆ RandomToTypeUniform()

template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T Eigen::internal::RandomToTypeUniform ( uint64_t state,
uint64_t  stream 
)

Definition at line 50 of file TensorRandom.h.

◆ RandomToTypeUniform< double >()

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double Eigen::internal::RandomToTypeUniform< double > ( uint64_t state,
uint64_t  stream 
)

Definition at line 94 of file TensorRandom.h.

◆ RandomToTypeUniform< Eigen::bfloat16 >()

Definition at line 67 of file TensorRandom.h.

◆ RandomToTypeUniform< Eigen::half >()

Definition at line 57 of file TensorRandom.h.

◆ RandomToTypeUniform< float >()

Definition at line 78 of file TensorRandom.h.

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

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<double> Eigen::internal::RandomToTypeUniform< std::complex< double > > ( uint64_t state,
uint64_t  stream 
)

Definition at line 119 of file TensorRandom.h.

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

template<>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<float> Eigen::internal::RandomToTypeUniform< std::complex< float > > ( uint64_t state,
uint64_t  stream 
)

Definition at line 114 of file TensorRandom.h.

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

Definition at line 159 of file ConditionEstimator.h.

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

Definition at line 56 of file ConditionEstimator.h.

◆ 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 
)

Definition at line 19 of file RealSvd2x2.h.

◆ ReducePacket()

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

Definition at line 118 of file TensorScan.h.

◆ ReduceScalar()

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

Definition at line 84 of file TensorScan.h.

◆ repeat()

template<int n, typename t >
constexpr array<t, n> Eigen::internal::repeat ( v)

Definition at line 483 of file CXX11Meta.h.

◆ 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  
)

Definition at line 750 of file AssignEvaluator.h.

◆ 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 > &   
)

Definition at line 759 of file AssignEvaluator.h.

◆ return_ptr()

template<typename T >
const T* Eigen::internal::return_ptr ( )

◆ rwupdt()

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

Definition at line 6 of file rwupdt.h.

◆ 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 
)

Definition at line 1035 of file SparseMatrix.h.

◆ shuffle1()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::shuffle1 ( const Packet4f m,
int  mask 
)

Definition at line 83 of file NEON/PacketMath.h.

◆ shuffle2()

template<bool interleave>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::shuffle2 ( const Packet4f m,
const Packet4f n,
int  mask 
)

Definition at line 94 of file NEON/PacketMath.h.

◆ shuffle2< true >()

template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::shuffle2< true > ( const Packet4f m,
const Packet4f n,
int  mask 
)

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

◆ size() [1/2]

template<typename T >
EIGEN_CONSTEXPR Index Eigen::internal::size ( const T x)

Definition at line 479 of file Meta.h.

◆ size() [2/2]

template<typename T , std::size_t N>
EIGEN_CONSTEXPR Index Eigen::internal::size ( const   T(&)[N])

Definition at line 482 of file Meta.h.

◆ skyline_col_major_time_dense_product()

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

Definition at line 185 of file SkylineProduct.h.

◆ skyline_row_major_time_dense_product()

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

Definition at line 122 of file SkylineProduct.h.

◆ smart_copy()

template<typename T >
EIGEN_DEVICE_FUNC void Eigen::internal::smart_copy ( const T start,
const T end,
T target 
)

Definition at line 515 of file Memory.h.

◆ smart_memmove()

template<typename T >
void Eigen::internal::smart_memmove ( const T start,
const T end,
T target 
)

Definition at line 539 of file Memory.h.

◆ smart_move()

template<typename T >
EIGEN_DEVICE_FUNC T* Eigen::internal::smart_move ( T start,
T end,
T target 
)

Definition at line 575 of file Memory.h.

◆ 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 
)

Definition at line 23 of file SparseSolverBase.h.

◆ 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 
)

Definition at line 47 of file SparseSolverBase.h.

◆ sortWithPermutation()

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

Computes a permutation vector to have a sorted sequence.

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

Definition at line 39 of file DGMRES.h.

◆ 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

Definition at line 283 of file SparseSelfAdjointView.h.

◆ 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

Definition at line 20 of file SparseSparseProductWithPruning.h.

◆ 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

Definition at line 270 of file ConservativeSparseSparseProduct.h.

◆ 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

Definition at line 169 of file SparseDenseProduct.h.

◆ 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 
)

Definition at line 26 of file SparseLU_gemm_kernel.h.

◆ stable_norm_impl() [1/2]

template<typename VectorType >
VectorType::RealScalar Eigen::internal::stable_norm_impl ( const VectorType vec,
typename enable_if< VectorType::IsVectorAtCompileTime >::type = 0 
)

Definition at line 82 of file StableNorm.h.

◆ stable_norm_impl() [2/2]

template<typename MatrixType >
MatrixType::RealScalar Eigen::internal::stable_norm_impl ( const MatrixType mat,
typename enable_if<!MatrixType::IsVectorAtCompileTime >::type = 0 
)

Definition at line 104 of file StableNorm.h.

◆ stable_norm_impl_inner_step()

template<typename VectorType , typename RealScalar >
void Eigen::internal::stable_norm_impl_inner_step ( const VectorType vec,
RealScalar ssq,
RealScalar scale,
RealScalar invScale 
)

Definition at line 54 of file StableNorm.h.

◆ stable_norm_kernel()

template<typename ExpressionType , typename Scalar >
void Eigen::internal::stable_norm_kernel ( const ExpressionType &  bl,
Scalar ssq,
Scalar scale,
Scalar invScale 
)
inline

Definition at line 18 of file StableNorm.h.

◆ stem_function_cos()

template<typename Scalar >
Scalar Eigen::internal::stem_function_cos ( Scalar  x,
int  n 
)

Cosine (and its derivatives).

Definition at line 27 of file StemFunction.h.

◆ stem_function_cosh()

template<typename Scalar >
Scalar Eigen::internal::stem_function_cosh ( Scalar  x,
int  n 
)

Hyperbolic cosine (and its derivatives).

Definition at line 77 of file StemFunction.h.

◆ stem_function_exp()

template<typename Scalar >
Scalar Eigen::internal::stem_function_exp ( Scalar  x,
int   
)

The exponential function (and its derivatives).

Definition at line 19 of file StemFunction.h.

◆ stem_function_sin()

template<typename Scalar >
Scalar Eigen::internal::stem_function_sin ( Scalar  x,
int  n 
)

Sine (and its derivatives).

Definition at line 52 of file StemFunction.h.

◆ stem_function_sinh()

template<typename Scalar >
Scalar Eigen::internal::stem_function_sinh ( Scalar  x,
int  n 
)

Hyperbolic sine (and its derivatives).

Definition at line 96 of file StemFunction.h.

◆ storeAccumulator()

template<typename DataMapper , typename Index , typename Packet , const Index accCols>
EIGEN_ALWAYS_INLINE void Eigen::internal::storeAccumulator ( Index  i,
Index  j,
const DataMapper &  data,
const Packet alpha,
__vector_quad *  acc 
)

Definition at line 33 of file MatrixProductMMA.h.

◆ storeBlock() [1/2]

template<typename Scalar , typename Packet , typename Index >
EIGEN_ALWAYS_INLINE void Eigen::internal::storeBlock ( Scalar to,
PacketBlock< Packet, 4 > &  block 
)

PanelMode Packing might be called several times before being multiplied by gebp_kernel, this happens because on special occasions it fills part of block with other parts of the matrix. Two variables control how PanelMode should behave: offset and stride. The idea is that those variables represent whatever is going to be the real offset and stride in the future and this is what you should obey. The process is to behave as you would with normal packing but leave the start of each part with the correct offset and the end as well respecting the real stride the block will have. Gebp is aware of both blocks stride and offset and behaves accordingly.

Definition at line 410 of file MatrixProduct.h.

◆ storeBlock() [2/2]

template<typename Scalar , typename Packet , typename Index >
EIGEN_ALWAYS_INLINE void Eigen::internal::storeBlock ( Scalar to,
PacketBlock< Packet, 2 > &  block 
)

Definition at line 420 of file MatrixProduct.h.

◆ storeComplexAccumulator()

template<typename DataMapper , typename Index , typename Packet , typename Packetc , const Index accColsC, int N>
EIGEN_ALWAYS_INLINE void Eigen::internal::storeComplexAccumulator ( Index  i,
Index  j,
const DataMapper &  data,
const Packet alphaReal,
const Packet alphaImag,
__vector_quad *  accReal,
__vector_quad *  accImag 
)

Definition at line 47 of file MatrixProductMMA.h.

◆ strides() [1/3]

template<int Layout, typename IndexType , int NumDims>
EIGEN_ALWAYS_INLINE DSizes<IndexType, NumDims> Eigen::internal::strides ( const DSizes< IndexType, NumDims > &  dimensions)

Definition at line 26 of file TensorBlock.h.

◆ strides() [2/3]

template<int Layout, typename IndexType , size_t NumDims>
EIGEN_ALWAYS_INLINE DSizes<IndexType, NumDims> Eigen::internal::strides ( const Eigen::array< IndexType, NumDims > &  dimensions)

Definition at line 49 of file TensorBlock.h.

◆ strides() [3/3]

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

Definition at line 55 of file TensorBlock.h.

◆ swap()

template<typename T >
void Eigen::internal::swap ( scoped_array< T > &  a,
scoped_array< T > &  b 
)

Definition at line 709 of file Memory.h.

◆ symm_pack_complex_lhs_helper()

template<typename Scalar , typename Index , int StorageOrder>
EIGEN_STRONG_INLINE void Eigen::internal::symm_pack_complex_lhs_helper ( std::complex< Scalar > *  blockA,
const std::complex< Scalar > *  _lhs,
Index  lhsStride,
Index  cols,
Index  rows 
)

Definition at line 189 of file MatrixProduct.h.

◆ symm_pack_complex_rhs_helper()

template<typename Scalar , typename Index , int StorageOrder, int N>
EIGEN_STRONG_INLINE void Eigen::internal::symm_pack_complex_rhs_helper ( std::complex< Scalar > *  blockB,
const std::complex< Scalar > *  _rhs,
Index  rhsStride,
Index  rows,
Index  cols,
Index  k2 
)

Definition at line 139 of file MatrixProduct.h.

◆ symm_pack_lhs_helper()

template<typename Scalar , typename Index , int StorageOrder>
EIGEN_STRONG_INLINE void Eigen::internal::symm_pack_lhs_helper ( Scalar blockA,
const Scalar _lhs,
Index  lhsStride,
Index  cols,
Index  rows 
)

Definition at line 281 of file MatrixProduct.h.

◆ symm_pack_rhs_helper()

template<typename Scalar , typename Index , int StorageOrder, int N>
EIGEN_STRONG_INLINE void Eigen::internal::symm_pack_rhs_helper ( Scalar blockB,
const Scalar _rhs,
Index  rhsStride,
Index  rows,
Index  cols,
Index  k2 
)

Definition at line 240 of file MatrixProduct.h.

◆ tensor_static_symgroup_index_permute() [1/2]

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

Definition at line 122 of file StaticSymmetry.h.

◆ tensor_static_symgroup_index_permute() [2/2]

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

Definition at line 128 of file StaticSymmetry.h.

◆ throw_std_bad_alloc()

EIGEN_DEVICE_FUNC void Eigen::internal::throw_std_bad_alloc ( )
inline

Definition at line 67 of file Memory.h.

◆ toRotationMatrix() [1/3]

template<typename Scalar , int Dim>
static EIGEN_DEVICE_FUNC Matrix<Scalar,2,2> Eigen::internal::toRotationMatrix ( const Scalar s)
inlinestatic

Definition at line 182 of file RotationBase.h.

◆ 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

Definition at line 189 of file RotationBase.h.

◆ toRotationMatrix() [3/3]

template<typename Scalar , int Dim, typename OtherDerived >
static EIGEN_DEVICE_FUNC const MatrixBase<OtherDerived>& Eigen::internal::toRotationMatrix ( const MatrixBase< OtherDerived > &  mat)
inlinestatic

Definition at line 195 of file RotationBase.h.

◆ treePostorder()

template<typename IndexVector >
void Eigen::internal::treePostorder ( typename IndexVector::Scalar  n,
IndexVector &  parent,
IndexVector &  post 
)

Post order a tree.

Parameters
nthe number of nodes
parentInput tree
postpostordered tree

Definition at line 178 of file SparseColEtree.h.

◆ 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

Definition at line 839 of file SelfAdjointEigenSolver.h.

◆ tridiagonalization_inplace() [1/2]

template<typename MatrixType , typename CoeffVectorType >
EIGEN_DEVICE_FUNC void Eigen::internal::tridiagonalization_inplace ( MatrixType matA,
CoeffVectorType &  hCoeffs 
)

Definition at line 349 of file Tridiagonalization.h.

◆ tridiagonalization_inplace() [2/2]

template<typename MatrixType , typename DiagonalType , typename SubDiagonalType , typename CoeffVectorType >
EIGEN_DEVICE_FUNC void Eigen::internal::tridiagonalization_inplace ( MatrixType mat,
DiagonalType &  diag,
SubDiagonalType &  subdiag,
CoeffVectorType &  hcoeffs,
bool  extractQ 
)

Performs a full tridiagonalization in place.

Parameters
[in,out]matOn 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]diagThe diagonal of the tridiagonal matrix T in the decomposition.
[out]subdiagThe subdiagonal of the tridiagonal matrix T in the decomposition.
[in]extractQIf 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 $ mat = Q T Q^* $ where $ Q $ is unitary and $ T $ 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&)):

MatrixXd X = MatrixXd::Random(5,5);
MatrixXd A = X + X.transpose();
cout << "Here is a random symmetric 5x5 matrix:" << endl << A << endl << endl;
VectorXd diag(5);
VectorXd subdiag(4);
VectorXd hcoeffs(4); // Scratch space for householder reflector.
internal::tridiagonalization_inplace(A, diag, subdiag, hcoeffs, true);
cout << "The orthogonal matrix Q is:" << endl << A << endl;
cout << "The diagonal of the tridiagonal matrix T is:" << endl << diag << endl;
cout << "The subdiagonal of the tridiagonal matrix T is:" << endl << subdiag << endl;

Output:

See also
class Tridiagonalization

Definition at line 430 of file Tridiagonalization.h.

◆ trig_reduce_huge()

float Eigen::internal::trig_reduce_huge ( float  xf,
int quadrant 
)
inline

Definition at line 565 of file GenericPacketMathFunctions.h.

◆ twoprod() [1/3]

template<typename Packet >
EIGEN_STRONG_INLINE void Eigen::internal::twoprod ( const Packet x,
const Packet y,
Packet p_hi,
Packet p_lo 
)

Definition at line 936 of file GenericPacketMathFunctions.h.

◆ twoprod() [2/3]

template<typename Packet >
EIGEN_STRONG_INLINE void Eigen::internal::twoprod ( const Packet x_hi,
const Packet x_lo,
const Packet y,
Packet p_hi,
Packet p_lo 
)

Definition at line 1014 of file GenericPacketMathFunctions.h.

◆ twoprod() [3/3]

template<typename Packet >
EIGEN_STRONG_INLINE void Eigen::internal::twoprod ( const Packet x_hi,
const Packet x_lo,
const Packet y_hi,
const Packet y_lo,
Packet p_hi,
Packet p_lo 
)

Definition at line 1033 of file GenericPacketMathFunctions.h.

◆ twosum()

template<typename Packet >
EIGEN_STRONG_INLINE void Eigen::internal::twosum ( const Packet x_hi,
const Packet x_lo,
const Packet y_hi,
const Packet y_lo,
Packet s_hi,
Packet s_lo 
)

Definition at line 960 of file GenericPacketMathFunctions.h.

◆ 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 
)

Definition at line 152 of file UpperBidiagonalization.h.

◆ 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 
)

Definition at line 284 of file UpperBidiagonalization.h.

◆ 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 
)

Definition at line 93 of file UpperBidiagonalization.h.

◆ useSpecificBlockingSizes()

template<typename Index >
bool Eigen::internal::useSpecificBlockingSizes ( Index k,
Index m,
Index n 
)
inline

Definition at line 305 of file products/GeneralBlockPanelKernel.h.

◆ vec2d_unpackhi()

EIGEN_STRONG_INLINE Packet2d Eigen::internal::vec2d_unpackhi ( const Packet2d a,
const Packet2d b 
)

Definition at line 102 of file SSE/PacketMath.h.

◆ vec2d_unpacklo()

EIGEN_STRONG_INLINE Packet2d Eigen::internal::vec2d_unpacklo ( const Packet2d a,
const Packet2d b 
)

Definition at line 98 of file SSE/PacketMath.h.

◆ vec4f_movehl()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec4f_movehl ( const Packet4f a,
const Packet4f b 
)

Definition at line 125 of file NEON/PacketMath.h.

◆ vec4f_movelh()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec4f_movelh ( const Packet4f a,
const Packet4f b 
)

Definition at line 121 of file NEON/PacketMath.h.

◆ vec4f_swizzle1()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec4f_swizzle1 ( const Packet4f a,
int  p,
int  q,
int  r,
int  s 
)

Definition at line 113 of file NEON/PacketMath.h.

◆ vec4f_swizzle2()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec4f_swizzle2 ( const Packet4f a,
const Packet4f b,
int  p,
int  q,
int  r,
int  s 
)

Definition at line 117 of file NEON/PacketMath.h.

◆ vec4f_unpackhi()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec4f_unpackhi ( const Packet4f a,
const Packet4f b 
)

Definition at line 133 of file NEON/PacketMath.h.

◆ vec4f_unpacklo()

EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec4f_unpacklo ( const Packet4f a,
const Packet4f b 
)

Definition at line 129 of file NEON/PacketMath.h.

◆ vec_splat_packet4f()

template<int element>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec_splat_packet4f ( const Packet4f from)

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

◆ veltkamp_splitting()

template<typename Packet >
EIGEN_STRONG_INLINE void Eigen::internal::veltkamp_splitting ( const Packet x,
Packet x_hi,
Packet x_lo 
)

Definition at line 920 of file GenericPacketMathFunctions.h.

Variable Documentation

◆ arg_prod

template<typename... Ts>
EIGEN_DEVICE_FUNC constexprdecltype(reduce<product_op, Ts...>::run((*((Ts*)0))...)) EIGEN_STRONG_INLIN Eigen::internal::arg_prod) (Ts... ts)

Definition at line 324 of file CXX11Meta.h.

◆ arg_sum

template<typename... Ts>
constexprdecltype(reduce<sum_op, Ts...>::run((*((Ts*)0))...)) EIGEN_STRONG_INLIN Eigen::internal::arg_sum) (Ts... ts)

Definition at line 330 of file CXX11Meta.h.

◆ defaultL1CacheSize

const std::ptrdiff_t Eigen::internal::defaultL1CacheSize = EIGEN_SET_DEFAULT_L1_CACHE_SIZE(16*1024)

Definition at line 61 of file products/GeneralBlockPanelKernel.h.

◆ defaultL2CacheSize

const std::ptrdiff_t Eigen::internal::defaultL2CacheSize = EIGEN_SET_DEFAULT_L2_CACHE_SIZE(512*1024)

Definition at line 62 of file products/GeneralBlockPanelKernel.h.

◆ defaultL3CacheSize

const std::ptrdiff_t Eigen::internal::defaultL3CacheSize = EIGEN_SET_DEFAULT_L3_CACHE_SIZE(512*1024)

Definition at line 63 of file products/GeneralBlockPanelKernel.h.

◆ kLeafSize

const int Eigen::internal::kLeafSize = 1024
static

Definition at line 199 of file TensorReduction.h.

◆ mask21

const Packet2l Eigen::internal::mask21 = { -1, 0 }
static

Definition at line 1250 of file MatrixProduct.h.

◆ mask41

const Packet4i Eigen::internal::mask41 = { -1, 0, 0, 0 }
static

Definition at line 1246 of file MatrixProduct.h.

◆ mask42

const Packet4i Eigen::internal::mask42 = { -1, -1, 0, 0 }
static

Definition at line 1247 of file MatrixProduct.h.

◆ mask43

const Packet4i Eigen::internal::mask43 = { -1, -1, -1, 0 }
static

Definition at line 1248 of file MatrixProduct.h.

◆ matrix_function_separation

const float Eigen::internal::matrix_function_separation = 0.1f
static

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

Definition at line 21 of file MatrixFunction.h.

◆ p16c_COUNTDOWN

Packet16c Eigen::internal::p16c_COUNTDOWN
static
Initial value:
= { 0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15}

Definition at line 96 of file AltiVec/PacketMath.h.

◆ p16uc_COMPLEX32_REV [1/2]

Packet16uc Eigen::internal::p16uc_COMPLEX32_REV = vec_sld(p16uc_REVERSE32, p16uc_REVERSE32, 8)
static

Definition at line 136 of file AltiVec/PacketMath.h.

◆ p16uc_COMPLEX32_REV [2/2]

Packet16uc Eigen::internal::p16uc_COMPLEX32_REV = vec_sld(p16uc_REVERSE32, p16uc_REVERSE32, 8)
static

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

◆ p16uc_COMPLEX32_REV2 [1/2]

Packet16uc Eigen::internal::p16uc_COMPLEX32_REV2 = vec_sld(p16uc_PSET64_HI, p16uc_PSET64_LO, 8)
static

Definition at line 141 of file AltiVec/PacketMath.h.

◆ p16uc_COMPLEX32_REV2 [2/2]

Packet16uc Eigen::internal::p16uc_COMPLEX32_REV2 = vec_sld(p16uc_FORWARD, p16uc_FORWARD, 8)
static

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

◆ p16uc_COUNTDOWN

Packet16uc Eigen::internal::p16uc_COUNTDOWN
static
Initial value:
= { 0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15}

Definition at line 98 of file AltiVec/PacketMath.h.

◆ p16uc_DUPLICATE16_EVEN

const Packet16uc Eigen::internal::p16uc_DUPLICATE16_EVEN = { 0,1 ,0,1, 4,5, 4,5, 8,9, 8,9, 12,13, 12,13 }
static

Definition at line 108 of file AltiVec/PacketMath.h.

◆ p16uc_DUPLICATE16_HI

Packet16uc Eigen::internal::p16uc_DUPLICATE16_HI = { 0,1,0,1, 2,3,2,3, 4,5,4,5, 6,7,6,7 }
static

Definition at line 106 of file AltiVec/PacketMath.h.

◆ p16uc_DUPLICATE16_ODD

const Packet16uc Eigen::internal::p16uc_DUPLICATE16_ODD = { 2,3 ,2,3, 6,7, 6,7, 10,11, 10,11, 14,15, 14,15 }
static

Definition at line 109 of file AltiVec/PacketMath.h.

◆ 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

Definition at line 105 of file AltiVec/PacketMath.h.

◆ 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

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

◆ p16uc_DUPLICATE8_HI

Packet16uc Eigen::internal::p16uc_DUPLICATE8_HI = { 0,0, 1,1, 2,2, 3,3, 4,4, 5,5, 6,6, 7,7 }
static

Definition at line 107 of file AltiVec/PacketMath.h.

◆ p16uc_FORWARD [1/2]

Packet16uc Eigen::internal::p16uc_FORWARD = p16uc_REVERSE32
static

Definition at line 124 of file AltiVec/PacketMath.h.

◆ 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

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

◆ p16uc_GETIMAG32

const Packet16uc Eigen::internal::p16uc_GETIMAG32
static
Initial value:
= { 4, 5, 6, 7,
12, 13, 14, 15,
20, 21, 22, 23,
28, 29, 30, 31}

Definition at line 90 of file MatrixProduct.h.

◆ p16uc_GETIMAG64

const Packet16uc Eigen::internal::p16uc_GETIMAG64
static
Initial value:
= { 8, 9, 10, 11, 12, 13, 14, 15,
24, 25, 26, 27, 28, 29, 30, 31}

Definition at line 98 of file MatrixProduct.h.

◆ p16uc_GETREAL32

const Packet16uc Eigen::internal::p16uc_GETREAL32
static
Initial value:
= { 0, 1, 2, 3,
8, 9, 10, 11,
16, 17, 18, 19,
24, 25, 26, 27}

Definition at line 85 of file MatrixProduct.h.

◆ p16uc_GETREAL64

const Packet16uc Eigen::internal::p16uc_GETREAL64
static
Initial value:
= { 0, 1, 2, 3, 4, 5, 6, 7,
16, 17, 18, 19, 20, 21, 22, 23}

Definition at line 94 of file MatrixProduct.h.

◆ 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

Definition at line 128 of file AltiVec/PacketMath.h.

◆ 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

Definition at line 127 of file AltiVec/PacketMath.h.

◆ 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

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

◆ 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

Definition at line 126 of file AltiVec/PacketMath.h.

◆ 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

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

◆ p16uc_PSET64_HI [1/2]

Packet16uc Eigen::internal::p16uc_PSET64_HI = { 0,1,2,3, 4,5,6,7, 0,1,2,3, 4,5,6,7 }
static

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

◆ p16uc_PSET64_HI [2/2]

Packet16uc Eigen::internal::p16uc_PSET64_HI = (Packet16uc) vec_mergeh((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN)
static

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

◆ p16uc_PSET64_LO [1/2]

Packet16uc Eigen::internal::p16uc_PSET64_LO = (Packet16uc) vec_mergel((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN)
static

Definition at line 132 of file AltiVec/PacketMath.h.

◆ p16uc_PSET64_LO [2/2]

Packet16uc Eigen::internal::p16uc_PSET64_LO = (Packet16uc) vec_mergel((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN)
static

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

◆ p16uc_QUADRUPLICATE16_HI

Packet16uc Eigen::internal::p16uc_QUADRUPLICATE16_HI = { 0,1,0,1,0,1,0,1, 2,3,2,3,2,3,2,3 }
static

Definition at line 111 of file AltiVec/PacketMath.h.

◆ p16uc_REVERSE16

Packet16uc Eigen::internal::p16uc_REVERSE16 = { 14,15, 12,13, 10,11, 8,9, 6,7, 4,5, 2,3, 0,1 }
static

Definition at line 102 of file AltiVec/PacketMath.h.

◆ 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

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

◆ 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

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

◆ 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

Definition at line 125 of file AltiVec/PacketMath.h.

◆ 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

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

◆ p16uc_REVERSE8

Packet16uc Eigen::internal::p16uc_REVERSE8 = { 15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0 }
static

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

◆ p16uc_SETCOMPLEX32_FIRST

const Packet16uc Eigen::internal::p16uc_SETCOMPLEX32_FIRST
static
Initial value:
= { 0, 1, 2, 3,
16, 17, 18, 19,
4, 5, 6, 7,
20, 21, 22, 23}

Definition at line 124 of file MatrixProductCommon.h.

◆ p16uc_SETCOMPLEX32_SECOND

const Packet16uc Eigen::internal::p16uc_SETCOMPLEX32_SECOND
static
Initial value:
= { 8, 9, 10, 11,
24, 25, 26, 27,
12, 13, 14, 15,
28, 29, 30, 31}

Definition at line 129 of file MatrixProductCommon.h.

◆ p16uc_SETCOMPLEX64_FIRST

const Packet16uc Eigen::internal::p16uc_SETCOMPLEX64_FIRST
static
Initial value:
= { 0, 1, 2, 3, 4, 5, 6, 7,
16, 17, 18, 19, 20, 21, 22, 23}

Definition at line 134 of file MatrixProductCommon.h.

◆ p16uc_SETCOMPLEX64_SECOND

const Packet16uc Eigen::internal::p16uc_SETCOMPLEX64_SECOND
static
Initial value:
= { 8, 9, 10, 11, 12, 13, 14, 15,
24, 25, 26, 27, 28, 29, 30, 31}

Definition at line 138 of file MatrixProductCommon.h.

◆ p16uc_TRANSPOSE64_HI [1/2]

Packet16uc Eigen::internal::p16uc_TRANSPOSE64_HI = p16uc_PSET64_HI + p16uc_HALF64_0_16
static

Definition at line 133 of file AltiVec/PacketMath.h.

◆ 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

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

◆ p16uc_TRANSPOSE64_LO [1/2]

Packet16uc Eigen::internal::p16uc_TRANSPOSE64_LO = p16uc_PSET64_LO + p16uc_HALF64_0_16
static

Definition at line 134 of file AltiVec/PacketMath.h.

◆ 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

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

◆ p2d_COUNTDOWN

Packet2d Eigen::internal::p2d_COUNTDOWN = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet16uc>(p2d_ZERO), reinterpret_cast<Packet16uc>(p2d_ONE), 8))
static

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

◆ p2d_ONE

Packet2d Eigen::internal::p2d_ONE = { 1.0, 1.0 }
static

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

◆ p2d_ZERO_

Packet2d Eigen::internal::p2d_ZERO_
static
Initial value:
= { numext::bit_cast<double>0x8000000000000000ull),
numext::bit_cast<double>0x8000000000000000ull) }
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Tgt bit_cast(const Src &src)
Definition: NumTraits.h:85

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

◆ p2ul_CONJ_XOR1

Packet2ul Eigen::internal::p2ul_CONJ_XOR1 = (Packet2ul) vec_sld((Packet4ui) p2d_ZERO_, (Packet4ui) p2l_ZERO, 8)
static

Definition at line 22 of file ZVector/Complex.h.

◆ p2ul_CONJ_XOR2

Packet2ul Eigen::internal::p2ul_CONJ_XOR2 = (Packet2ul) vec_sld((Packet4ui) p2l_ZERO, (Packet4ui) p2d_ZERO_, 8)
static

Definition at line 23 of file ZVector/Complex.h.

◆ p4f_COUNTDOWN [1/2]

Packet4f Eigen::internal::p4f_COUNTDOWN = { 0.0, 1.0, 2.0, 3.0 }
static

Definition at line 91 of file AltiVec/PacketMath.h.

◆ p4f_COUNTDOWN [2/2]

Packet4f Eigen::internal::p4f_COUNTDOWN = { 0.0, 1.0, 2.0, 3.0 }
static

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

◆ p4f_MZERO [1/2]

Packet4f Eigen::internal::p4f_MZERO = (Packet4f) vec_sl((Packet4ui)p4i_MINUS1, (Packet4ui)p4i_MINUS1)
static

Definition at line 86 of file AltiVec/PacketMath.h.

◆ p4f_MZERO [2/2]

Packet4f Eigen::internal::p4f_MZERO = { 0x80000000, 0x80000000, 0x80000000, 0x80000000}
static

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

◆ p4f_ONE

Packet4f Eigen::internal::p4f_ONE = vec_ctf(p4i_ONE, 0)
static

Definition at line 88 of file AltiVec/PacketMath.h.

◆ p4i_COUNTDOWN [1/2]

Packet4i Eigen::internal::p4i_COUNTDOWN = { 0, 1, 2, 3 }
static

Definition at line 92 of file AltiVec/PacketMath.h.

◆ p4i_COUNTDOWN [2/2]

Packet4i Eigen::internal::p4i_COUNTDOWN = { 0, 1, 2, 3 }
static

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

◆ p4ui_CONJ_XOR [1/2]

Packet4ui Eigen::internal::p4ui_CONJ_XOR = vec_mergeh((Packet4ui)p4i_ZERO, (Packet4ui)p4f_MZERO)
static

Definition at line 18 of file AltiVec/Complex.h.

◆ p4ui_CONJ_XOR [2/2]

Packet4ui Eigen::internal::p4ui_CONJ_XOR = { 0x00000000, 0x80000000, 0x00000000, 0x80000000 }
static

Definition at line 19 of file ZVector/Complex.h.

◆ p8s_COUNTDOWN

Packet8s Eigen::internal::p8s_COUNTDOWN = { 0, 1, 2, 3, 4, 5, 6, 7 }
static

Definition at line 93 of file AltiVec/PacketMath.h.

◆ p8us_COUNTDOWN

Packet8us Eigen::internal::p8us_COUNTDOWN = { 0, 1, 2, 3, 4, 5, 6, 7 }
static

Definition at line 94 of file AltiVec/PacketMath.h.

◆ y

const Scalar & Eigen::internal::y
Initial value:
{
return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(x, y)
SCALAR Scalar
Definition: bench_gemm.cpp:46
EIGEN_DEVICE_FUNC const Scalar & y
set noclip points set clip one set noclip two set bar set border lt lw set xdata set ydata set zdata set x2data set y2data set boxwidth set dummy x
#define EIGEN_MATHFUNC_IMPL(func, scalar)

Definition at line 821 of file Eigen/src/Core/MathFunctions.h.



gtsam
Author(s):
autogenerated on Tue Jul 4 2023 02:44:21