Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 1234]

CEigen::gpu::AdjointView< Scalar_ >	View returned by DeviceMatrix::adjoint(); maps to the cuBLAS conjugate-transpose operand flag
CEigen::AutoDiffScalar< DerivativeType >	A scalar type replacement with automatic differentiation capability
CEigen::AutoDiffScalar< DerType >
CEigen::AutoDiffScalar< Matrix< typename NumTraits< typename DerTypeCleaned::Scalar >::Real, DerTypeCleaned::RowsAtCompileTime, DerTypeCleaned::ColsAtCompileTime, 0, DerTypeCleaned::MaxRowsAtCompileTime, DerTypeCleaned::MaxColsAtCompileTime > >
CEigen::AutoDiffScalar< typename Eigen::internal::remove_all_t< DerType >::PlainObject >
CEigen::TensorSycl::internal::BlockProperties< is_transposed, is_rhs_, packet_load_, PacketType >	BlockProperties is a template class that provides different characteristic of a block of each Tensor processed by each workgroup
CEigen::internal::CoeffLoader< Tensor, HasRawAccess, MakePointer_ >
CEigen::gpu::ConstSelfAdjointView< Scalar_, UpLo_ >
CEigen::gpu::Context	Unified GPU execution context owning a CUDA stream and library handles
►CEigen::DenseCoeffsBase< Derived, DirectWriteAccessors > [external]
►CEigen::DenseBase< Derived > [external]
►CEigen::MatrixBase< AlignedVector3< Scalar_ > > [external]
CEigen::AlignedVector3< Scalar_ >	A vectorization friendly 3D vector
►CEigen::MatrixBase< typename Derived > [external]
CEigen::AlignedVector3< Scalar >
CEigen::gpu::internal::device_expr_traits< T >	Describes GPU device expression types
CEigen::gpu::DeviceAddExpr< Scalar_ >	Linear combination of two device matrices
CEigen::gpu::internal::DeviceBuffer	Internal RAII owner for an untyped GPU device allocation
CEigen::gpu::DeviceMatrix< Scalar_ >	RAII wrapper for a dense column-major matrix in GPU device memory
CEigen::gpu::DeviceScalar< Scalar_ >	RAII wrapper for a scalar in GPU device memory
CEigen::gpu::DeviceScaledDevice< Scalar_ >	Expression that scales a device matrix by a DeviceScalar
CEigen::DPR1EigenSolver< RealScalar_ >	Direct O(n^2) eigensolver for real symmetric diagonal-plus-rank-one matrices \( A = D + \rho\, z z^T \), via the secular equation
CEigen::DynamicSGroup	Dynamic symmetry group
►CEigen::EigenBase< typename Derived > [external]
CEigen::KroneckerOperator< typename LhsVisitable::type, typename RhsVisitable::type >
CEigen::KroneckerOperator< typename LhsOps::TransposedFactor, typename RhsOps::TransposedFactor >
CEigen::KroneckerOperator< typename LhsOps::InverseFactor, typename RhsOps::InverseFactor >
CEigen::KroneckerSum< typename LhsOps::TransposedFactor, typename RhsOps::TransposedFactor >
►CEigen::EigenBase< Bccb< Scalar_, BlockSize_, NumBlocks_ > > [external]
CEigen::Bccb< Scalar_, BlockSize_, NumBlocks_ >	A block circulant matrix with circulant blocks (BCCB), the matrix of a two-dimensional circular convolution, represented by its n2 x n1 generating array
►CEigen::EigenBase< Cauchy< Scalar_, Rows_, Cols_ > > [external]
CEigen::Cauchy< Scalar_, Rows_, Cols_ >	An m x n Cauchy matrix represented by its two node vectors
►CEigen::EigenBase< Circulant< Scalar_, Size_ > > [external]
CEigen::Circulant< Scalar_, Size_ >	An n x n circulant matrix represented by its first column
►CEigen::EigenBase< Derived > [external]
►CEigen::SolverBase< BartelsStewart< KroneckerSumType > > [external]
CEigen::BartelsStewart< KroneckerSumType >	Direct solver for Kronecker-sum systems \( (A_1 \oplus A_2 \oplus \cdots \oplus A_d)\,x = b \)
►CEigen::SolverBase< BjorckPereyra< Scalar_ > > [external]
CEigen::BjorckPereyra< Scalar_ >	Björck-Pereyra O(n^2) solver for square Vandermonde systems
►CEigen::SolverBase< CauchyLU< Scalar_ > > [external]
CEigen::CauchyLU< Scalar_ >	Partially pivoted O(n^2) LU solver for square Cauchy systems (Gohberg-Kailath-Olshevsky)
►CEigen::SolverBase< LookAheadLevinson< Scalar_ > > [external]
CEigen::LookAheadLevinson< Scalar_ >	Look-ahead Levinson direct solver for general Toeplitz systems
►CEigen::SolverBase< BartelsStewart< Eigen::KroneckerSum > > [external]
CEigen::BartelsStewart< Eigen::KroneckerSum >
►CEigen::EigenBase< DeviceSparseView< Scalar > > [external]
CEigen::gpu::DeviceSparseView< Scalar >
►CEigen::EigenBase< DeviceSparseView< Scalar_ > > [external]
CEigen::gpu::DeviceSparseView< Scalar_ >
►CEigen::EigenBase< DiagonalPlusLowRank< Scalar_, Size_, Rank_ > > [external]
CEigen::DiagonalPlusLowRank< Scalar_, Size_, Rank_ >	An n x n operator \( D + U V^H \): a diagonal matrix plus a rank-k correction, stored as its diagonal and the two n x k factors
►CEigen::EigenBase< Hankel< Scalar_, Rows_, Cols_ > > [external]
CEigen::Hankel< Scalar_, Rows_, Cols_ >	An m x n Hankel matrix represented by its first column and last row
►CEigen::EigenBase< KroneckerOperator< LhsMatrix, RhsMatrix > > [external]
CEigen::KroneckerOperator< typename kron_factor_spectrum< LhsMatrix >::Eigenvectors, typename kron_factor_spectrum< RhsMatrix >::Eigenvectors >
CEigen::KroneckerOperator< typename kron_factor_spectrum< LhsMatrix >::SingularVectors, typename kron_factor_spectrum< RhsMatrix >::SingularVectors >
CEigen::KroneckerOperator< LhsMatrix, RhsMatrix >	The Kronecker product \( A \otimes B \) as an implicit operator that is never materialized
►CEigen::EigenBase< KroneckerSum< LhsMatrix, RhsMatrix > > [external]
CEigen::KroneckerSum< LhsMatrix, RhsMatrix >	The Kronecker sum \( A \oplus B = A \otimes I + I \otimes B \) of two square matrices as an implicit operator that is never materialized
►CEigen::EigenBase< Toeplitz< Scalar_, Rows_, Cols_ > > [external]
CEigen::Toeplitz< Scalar_, Rows_, Cols_ >	An m x n Toeplitz matrix represented by its first column and row
►CEigen::EigenBase< Vandermonde< Scalar_, Rows_, Cols_ > > [external]
CEigen::Vandermonde< Scalar_, Rows_, Cols_ >	An m x n Vandermonde matrix represented by its node vector
CEigen::EulerSystem< _AlphaAxis, _BetaAxis, _GammaAxis >	Represents a fixed Euler rotation system
CEigen::gpu::GemmExpr< Lhs, Rhs >	Expression returned by operator*(lhs_expr, rhs_expr), dispatched to cuBLAS GEMM
CEigen::TensorSycl::internal::GeneralScalarContraction< OutScalar, LhsScalar, RhsScalar, OutAccessor, LhsMapper, RhsMapper, StorageIndex, Vectorizable >	GeneralScalarContraction is a template class that provides the scalar value of Tensor -Tensor contraction operation, when all the dimensions are contracting dimensions. This Kernel reduces two tensors to a scalar
CEigen::TensorSycl::internal::GeneralVectorTensor< OutScalar, OutAccessor, VectorMapper, TensorMapper, StorageIndex, Properties, KFactor, Vectorizable, is_lhs_vec, IsFinal >	GeneralVectorTensor is a template class that provides Tensor -vector contraction operation, which is a special case of Tensor Tensor contraction
CEigen::gpu::HostTransfer< Scalar_ >	Future for an asynchronous device-to-host matrix transfer
CEigen::HybridNonLinearSolver< FunctorType, Scalar >	Finds a zero of a system of n nonlinear functions in n variables by a modification of the Powell hybrid method ("dogleg")
CEigen::internal::Initializer< Derived, N >	Helper template to initialize Tensors from std::initializer_lists
CEigen::gpu::is_adjoint_view< T >
CEigen::gpu::is_complex< T >
CEigen::gpu::is_const_selfadjoint_view< T >
CEigen::gpu::is_device_add_expr< T >
CEigen::gpu::is_device_buffer< T >
CEigen::gpu::is_device_expr< T >
CEigen::gpu::is_device_matrix< T >
CEigen::gpu::is_device_scalar< T >
CEigen::gpu::is_device_scaled_device< T >
CEigen::gpu::is_gemm_expr< T >
CEigen::gpu::is_host_scalar< T >
CEigen::gpu::is_llt_solve_expr< T >
CEigen::gpu::is_llt_view< T >
CEigen::gpu::is_lu_solve_expr< T >
CEigen::gpu::is_lu_view< T >
CEigen::gpu::is_scaled< T >
CEigen::gpu::internal::is_scaled_gemm< T >	Detects a Scaled directly over a GemmExpr (a product carrying ONE deferred scalar)
►CEigen::gpu::internal::is_scaled_gemm< std::decay_t< T > >
CEigen::gpu::is_scaled_gemm< T >
CEigen::gpu::internal::is_scaled_leaf< T >	Detects a Scaled directly over a leaf DeviceMatrix (no view in between)
►CEigen::gpu::internal::is_scaled_leaf< std::decay_t< T > >
CEigen::gpu::is_scaled_leaf< T >
CEigen::gpu::is_selfadjoint_view< T >
CEigen::gpu::is_symm_expr< T >
CEigen::gpu::is_syrk_expr< T >
CEigen::gpu::is_transpose_view< T >
CEigen::gpu::is_triangular_view< T >
CEigen::gpu::is_trsm_expr< T >
CEigen::KahanSum< Scalar >	Kahan algorithm based accumulator
CEigen::KdBVH< Scalar_, Dim_, Object_ >	A simple bounding volume hierarchy based on AlignedBox
CEigen::KroneckerProductBase< Derived >	The base class of dense and sparse Kronecker product
CEigen::KroneckerProductBase< KroneckerProduct >
►CEigen::KroneckerProductBase< KroneckerProduct< Lhs, Rhs > >
CEigen::KroneckerProduct< Lhs, Rhs >	Kronecker tensor product helper class for dense matrices
CEigen::KroneckerProductBase< KroneckerProductSparse >
►CEigen::KroneckerProductBase< KroneckerProductSparse< Lhs, Rhs > >
CEigen::KroneckerProductSparse< Lhs, Rhs >	Kronecker tensor product helper class for sparse matrices
CEigen::LevenbergMarquardt< FunctorType_ >	Performs non linear optimization over a non-linear function, using a variant of the Levenberg Marquardt algorithm
CEigen::gpu::LLT< Scalar_, UpLo_ >	GPU Cholesky (LL^T) decomposition via cuSOLVER
CEigen::gpu::LltSolveExpr< Scalar_, UpLo_ >
CEigen::gpu::LLTView< Scalar_, UpLo_ >
CEigen::gpu::LU< Scalar_ >	GPU LU decomposition with partial pivoting via cuSOLVER
CEigen::gpu::LuSolveExpr< Scalar_ >
CEigen::gpu::LUView< Scalar_ >
CEigen::internal::matrix_exp_computeUV< MatrixType, RealScalar >	Compute the (17,17)-Padé approximant to the exponential
CEigen::internal::matrix_exp_scale_impl< MatrixType, HasWritableRealView >	Scale a real or complex matrix by \( 2^{-s} \)
CEigen::internal::matrix_function_compute< MatrixType, IsComplex >	Class for computing matrix functions
CEigen::internal::matrix_sqrt_compute< MatrixType, IsComplex >	Helper struct for computing matrix square roots of general matrices
CEigen::MatrixComplexPowerReturnValue< Derived >	Proxy for the matrix power of some matrix (expression)
CEigen::MatrixExponentialReturnValue< Derived >	Proxy for the matrix exponential of some matrix (expression)
CEigen::internal::MatrixFunctionAtomic< MatrixType >	Helper class for computing matrix functions of atomic matrices
CEigen::MatrixFunctionReturnValue< Derived >	Proxy for the matrix function of some matrix (expression)
CEigen::internal::MatrixLogarithmAtomic< MatrixType >	Helper class for computing matrix logarithm of atomic matrices
CEigen::MatrixLogarithmReturnValue< Derived >	Proxy for the matrix logarithm of some matrix (expression)
CEigen::MatrixMarketIterator< Scalar >	Iterator to browse matrices from a specified folder
CEigen::MatrixPower< MatrixType >	Class for computing matrix powers
CEigen::MatrixPowerAtomic< MatrixType >	Class for computing matrix powers
CEigen::MatrixPowerParenthesesReturnValue< MatrixType >	Proxy for the matrix power of some matrix
CEigen::MatrixPowerReturnValue< Derived >	Proxy for the matrix power of some matrix (expression)
CEigen::MatrixSquareRootReturnValue< Derived >	Proxy for the matrix square root of some matrix (expression)
CEigen::TensorSycl::internal::TensorContractionKernel< OutScalar, LhsScalar, RhsScalar, OutAccessor, LhsMapper, RhsMapper, StorageIndex, Properties, TripleDim, Vectorizable, input_mapper_properties, IsFinal, contraction_tp >::MemHolder< contraction_type, StorageIndex >	MemHolder this is a place holder struct for creating memory hierarchy in SYCL. Inside SYCL kernel it is not allowed to have dynamic memory allocation. While the local memory is created outside of the kernel and passed to the kernel as an accessor, the private memory can only allowed to be allocated statically. Since we are abstracting the TiledMemory for both local and private memory, the MemHolder structs is used as a helper to abstract out different type of memory needed when local/no_local memory computation is called
CEigen::TensorSycl::internal::TensorContractionKernel< OutScalar, LhsScalar, RhsScalar, OutAccessor, LhsMapper, RhsMapper, StorageIndex, Properties, TripleDim, Vectorizable, input_mapper_properties, IsFinal, contraction_tp >::MemHolder< contraction_type::no_local, MemSize >	Specialization of memHolder class when no local memory kernel is used
CEigen::NNLS< MatrixType_ >	Implementation of the Non-Negative Least Squares (NNLS) algorithm
CEigen::NumericalDiff< Functor_, mode >
►CEigen::PolynomialSolverBase< Scalar_, Deg_ >	Defined to be inherited by polynomial solvers: it provides convenient methods such as
CEigen::PolynomialSolver< Scalar_, Deg_ >	A polynomial solver
CEigen::PolynomialSolverBase< Scalar_, 1 >
CEigen::RandomSetter< SparseMatrixType, MapTraits, OuterPacketBits >	The RandomSetter is a wrapper object allowing to set/update a sparse matrix with random access
CEigen::internal::ReductionReturnType< Op, CoeffReturnType >
►CEigen::RotationBase< typename Derived, int Dim_ > [external]
CEigen::EulerAngles< float, EulerSystemXYZ >
CEigen::EulerAngles< float, EulerSystemXYX >
CEigen::EulerAngles< float, EulerSystemXZY >
CEigen::EulerAngles< float, EulerSystemXZX >
CEigen::EulerAngles< float, EulerSystemYZX >
CEigen::EulerAngles< float, EulerSystemYZY >
CEigen::EulerAngles< float, EulerSystemYXZ >
CEigen::EulerAngles< float, EulerSystemYXY >
CEigen::EulerAngles< float, EulerSystemZXY >
CEigen::EulerAngles< float, EulerSystemZXZ >
CEigen::EulerAngles< float, EulerSystemZYX >
CEigen::EulerAngles< float, EulerSystemZYZ >
CEigen::EulerAngles< double, EulerSystemXYZ >
CEigen::EulerAngles< double, EulerSystemXYX >
CEigen::EulerAngles< double, EulerSystemXZY >
CEigen::EulerAngles< double, EulerSystemXZX >
CEigen::EulerAngles< double, EulerSystemYZX >
CEigen::EulerAngles< double, EulerSystemYZY >
CEigen::EulerAngles< double, EulerSystemYXZ >
CEigen::EulerAngles< double, EulerSystemYXY >
CEigen::EulerAngles< double, EulerSystemZXY >
CEigen::EulerAngles< double, EulerSystemZXZ >
CEigen::EulerAngles< double, EulerSystemZYX >
CEigen::EulerAngles< double, EulerSystemZYZ >
►CEigen::RotationBase< EulerAngles< Scalar_, _System >, 3 > [external]
CEigen::EulerAngles< Scalar_, _System >	Represents a rotation in a 3 dimensional space as three Euler angles
CEigen::gpu::Scaled< Inner_ >	Expression returned by operator*(Scalar, DeviceMatrix/View), carrying the scalar factor
CEigen::gpu::SelfAdjointView< Scalar_, UpLo_ >
CEigen::SGroup< Gen >	Symmetry group, initialized from template arguments
CEigen::SparseInverse< Scalar >	Calculate sparse subset of inverse of sparse matrix
CEigen::gpu::internal::SparseSolverBase< Scalar_, Derived >
►CEigen::gpu::internal::SparseSolverBase< Scalar_, SparseLDLT< Scalar_, Lower > >
CEigen::gpu::SparseLDLT< Scalar_, UpLo_ >
►CEigen::gpu::internal::SparseSolverBase< Scalar_, SparseLLT< Scalar_, Lower > >
CEigen::gpu::SparseLLT< Scalar_, UpLo_ >
►CEigen::gpu::internal::SparseSolverBase< Scalar_, SparseLU< Scalar_ > >
CEigen::gpu::SparseLU< Scalar_ >
CEigen::gpu::SparseSolverConfig
CEigen::Spline< Scalar_, Dim_, Degree_ >	A class representing multi-dimensional spline curves
CEigen::SplineFitting< SplineType >	Spline fitting methods
CEigen::SplineTraits< Spline< Scalar_, Dim_, Degree_ >, _DerivativeOrder >	Compile-time attributes of the Spline class for fixed degree
CEigen::SplineTraits< Spline< Scalar_, Dim_, Degree_ >, Dynamic >	Compile-time attributes of the Spline class for Dynamic degree
CEigen::gpu::SpMVAffineExpr< Scalar_ >
CEigen::gpu::SpMVExpr< Scalar_ >
CEigen::StaticSGroup< Gen >	Static symmetry group
CEigen::StdMapTraits< Scalar >
CEigen::StdUnorderedMapTraits< Scalar >
CEigen::Stencil< Derivative, Scalar, Size >	Finite-difference weights on an arbitrarily spaced grid
CEigen::gpu::SymmExpr< Scalar_, UpLo_ >
CEigen::gpu::SyrkExpr< Scalar_, UpLo_ >
CEigen::TensorAsyncDevice< ExpressionType, DeviceType, DoneCallback >	Pseudo expression providing an operator = that will evaluate its argument asynchronously on the specified device. Currently only ThreadPoolDevice implements proper asynchronous execution, while the default and GPU devices just run the expression synchronously and call m_done() on completion
CEigen::internal::TensorAsyncExecutor< Expression, Device, DoneCallback, Vectorizable, Tiling >
►CEigen::TensorBase< Derived, AccessLevel >	The tensor base class
CEigen::TensorAssignOp< LeftArgType, RightArgType >
CEigen::TensorBroadcastingOp< Broadcast, ArgType >
CEigen::TensorChippingOp< DimId, ArgType >
CEigen::TensorConcatenationOp< Axis, LeftArgType, RightArgType >
CEigen::TensorContractionOp< Indices, LeftArgType, RightArgType, OutputKernelType >
CEigen::TensorConversionOp< Scalar, Arg >
CEigen::TensorConversionOp< Scalar, const typename ArgRead::Expression >
CEigen::TensorConversionOp< TargetType, ArgType >
CEigen::TensorConversionOp< TargetType, const ArgXprType >
CEigen::TensorConvolutionOp< Indices, InputArgType, KernelArgType >
CEigen::TensorCwiseBinaryOp< BinaryOp, Left, Right >
CEigen::TensorCwiseBinaryOp< TensorBlockReadFunctor< BinaryOp >, const typename LeftRead::Expression, const typename RightRead::Expression >
CEigen::TensorCwiseBinaryOp< BinaryOp, LeftArgType, RightArgType >
CEigen::TensorCwiseNullaryOp< NullaryOp, Arg >
CEigen::TensorCwiseNullaryOp< NullaryOp, const RunView >
CEigen::TensorCwiseNullaryOp< NullaryOp, ArgType >
CEigen::TensorCwiseNullaryOp< NullaryOp, const ArgXprType >
CEigen::TensorCwiseUnaryOp< UnaryOp, Arg >
CEigen::TensorCwiseUnaryOp< TensorBlockReadFunctor< UnaryOp >, const typename ArgRead::Expression >
CEigen::TensorCwiseUnaryOp< UnaryOp, ArgType >
CEigen::TensorFFTOp< FFT, ArgType, FFTResultType, FFTDir >
CEigen::TensorForcedEvalOp< ArgType >
CEigen::TensorGeneratorOp< Generator, ArgType >
CEigen::TensorImagePatchOp< Rows, Cols, ArgType >
CEigen::TensorIndexPairOp< ArgType >
CEigen::CoeffReturnType< ArgType >
CEigen::TensorInflationOp< Strides, ArgType >
CEigen::TensorMap< const Tensor< Scalar, 1, Layout, Index > >
CEigen::TensorMap< const Tensor< ScalarNoConst, NumDims, Layout, Index > >
CEigen::TensorPaddingOp< PaddingDimensions, ArgType >
CEigen::TensorPatchOp< PatchDim, ArgType >
CEigen::TensorReductionOp< Op, Dims, ArgType, MakePointer_ >
CEigen::TensorReshapingOp< NewDimensions, ArgType >
CEigen::TensorReverseOp< ReverseDimensions, ArgType >
CEigen::TensorRollOp< RollDimensions, ArgType >
CEigen::TensorScanOp< Op, ArgType >
CEigen::TensorShufflingOp< Shuffle, ArgType >
CEigen::TensorStridingOp< Strides, ArgType >
CEigen::TensorTraceOp< Dims, ArgType >
CEigen::TensorVolumePatchOp< Planes, Rows, Cols, ArgType >
CEigen::TensorBase< Derived >
►CEigen::TensorBase< Tensor< Scalar_, NumIndices_, Options_, IndexType_ > >
CEigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >	The tensor class
►CEigen::TensorBase< TensorAssignOp< LhsXprType, RhsXprType > >
CEigen::TensorAssignOp< LhsXprType, RhsXprType >
CEigen::TensorBase< TensorBlockView< Scalar, NumDims, Layout, Eigen::Index > >
CEigen::TensorBase< TensorBlockView< Scalar_, NumDims, Layout, IndexType > >
►CEigen::TensorBase< TensorBroadcastingOp< Broadcast, XprType >, ReadOnlyAccessors >
CEigen::TensorBroadcastingOp< Broadcast, XprType >
►CEigen::TensorBase< TensorChippingOp< DimId, XprType > >
CEigen::TensorChippingOp< DimId, XprType >
►CEigen::TensorBase< TensorConcatenationOp< Axis, LhsXprType, RhsXprType >, WriteAccessors >
CEigen::TensorConcatenationOp< Axis, LhsXprType, RhsXprType >	Tensor concatenation class
►CEigen::TensorBase< TensorContractionOp< Indices, LhsXprType, RhsXprType, const NoOpOutputKernel >, ReadOnlyAccessors >
CEigen::TensorContractionOp< Indices, LhsXprType, RhsXprType, OutputKernelType >
►CEigen::TensorBase< TensorConversionOp< TargetType, XprType >, ReadOnlyAccessors >
CEigen::TensorConversionOp< TargetType, XprType >	Tensor conversion class. This class makes it possible to vectorize type casting operations when the number of scalars per packet in the source and the destination type differ
►CEigen::TensorBase< TensorConvolutionOp< Indices, InputXprType, KernelXprType >, ReadOnlyAccessors >
CEigen::TensorConvolutionOp< Indices, InputXprType, KernelXprType >
►CEigen::TensorBase< TensorCustomBinaryOp< CustomBinaryFunc, LhsXprType, RhsXprType >, ReadOnlyAccessors >
CEigen::TensorCustomBinaryOp< CustomBinaryFunc, LhsXprType, RhsXprType >	Tensor custom class
►CEigen::TensorBase< TensorCustomUnaryOp< CustomUnaryFunc, XprType >, ReadOnlyAccessors >
CEigen::TensorCustomUnaryOp< CustomUnaryFunc, XprType >	Tensor custom class
►CEigen::TensorBase< TensorCwiseBinaryOp< BinaryOp, LhsXprType, RhsXprType >, ReadOnlyAccessors >
CEigen::TensorCwiseBinaryOp< BinaryOp, LhsXprType, RhsXprType >	Tensor binary expression
►CEigen::TensorBase< TensorCwiseNullaryOp< NullaryOp, XprType >, ReadOnlyAccessors >
CEigen::TensorCwiseNullaryOp< NullaryOp, XprType >	Tensor nullary expression
CEigen::TensorBase< TensorCwiseTernaryOp< TernaryOp, Arg1XprType, Arg2XprType, Arg3XprType >, ReadOnlyAccessors >
►CEigen::TensorBase< TensorCwiseUnaryOp< UnaryOp, XprType >, ReadOnlyAccessors >
CEigen::TensorCwiseUnaryOp< UnaryOp, XprType >	Tensor unary expression
CEigen::TensorBase< TensorEvalToOp< XprType, MakePointer_ >, ReadOnlyAccessors >
►CEigen::TensorBase< TensorFFTOp< FFT, XprType, FFTResultType, FFTDir >, ReadOnlyAccessors >
CEigen::TensorFFTOp< FFT, XprType, FFTResultType, FFTDir >	Tensor FFT class
►CEigen::TensorBase< TensorFixedSize< Scalar_, Dimensions_, Options_, IndexType > >
CEigen::TensorFixedSize< Scalar_, Dimensions_, Options_, IndexType >	The fixed sized version of the tensor class
►CEigen::TensorBase< TensorForcedEvalOp< XprType >, ReadOnlyAccessors >
CEigen::TensorForcedEvalOp< XprType >	Tensor forced evaluation class
►CEigen::TensorBase< TensorGeneratorOp< Generator, XprType >, ReadOnlyAccessors >
CEigen::TensorGeneratorOp< Generator, XprType >	Tensor generator class
►CEigen::TensorBase< TensorImagePatchOp< Rows, Cols, XprType >, ReadOnlyAccessors >
CEigen::TensorImagePatchOp< Rows, Cols, XprType >	Patch extraction specialized for image processing. This assumes that the input has at least 3 dimensions ordered as follows: 1st dimension: channels (of size d) 2nd dimension: rows (of size r) 3rd dimension: columns (of size c) There can be additional dimensions such as time (for video) or batch (for bulk processing) after the first 3. Calling the image patch code with patch_rows and patch_cols is equivalent to calling the regular patch extraction code with parameters d, patch_rows, patch_cols, and 1 for all the additional dimensions
►CEigen::TensorBase< TensorIndexPairOp< XprType >, ReadOnlyAccessors >
CEigen::TensorIndexPairOp< XprType >	Tensor + Index Pair class
►CEigen::TensorBase< TensorInflationOp< Strides, XprType >, ReadOnlyAccessors >
CEigen::TensorInflationOp< Strides, XprType >	Tensor inflation class
CEigen::TensorBase< TensorLayoutSwapOp< XprType >, WriteAccessors >
►CEigen::TensorBase< TensorMap< PlainObjectType, Options_, MakePointer_ > >
CEigen::TensorMap< PlainObjectType, Options_, MakePointer_ >	A tensor expression mapping an existing array of data
►CEigen::TensorBase< TensorPaddingOp< PaddingDimensions, XprType >, ReadOnlyAccessors >
CEigen::TensorPaddingOp< PaddingDimensions, XprType >	Tensor padding class. At the moment only padding with a constant value is supported
CEigen::TensorBase< TensorPairReducerOp< ReduceOp, Dims, XprType >, ReadOnlyAccessors >
►CEigen::TensorBase< TensorPatchOp< PatchDim, XprType >, ReadOnlyAccessors >
CEigen::TensorPatchOp< PatchDim, XprType >	Tensor patch class
►CEigen::TensorBase< TensorReductionOp< Op, Dims, XprType, MakePointer_ >, ReadOnlyAccessors >
CEigen::TensorReductionOp< Op, Dims, XprType, MakePointer_ >	Tensor reduction class
►CEigen::TensorBase< TensorReductionOp< ReduceOp, Dims, const Eigen::TensorIndexPairOp< ArgType >, MakePointer_ >, ReadOnlyAccessors >
CEigen::TensorReductionOp< ReduceOp, Dims, const Eigen::TensorIndexPairOp< ArgType > >
►CEigen::TensorBase< TensorReshapingOp< NewDimensions, XprType >, WriteAccessors >
CEigen::TensorReshapingOp< NewDimensions, XprType >	Tensor reshaping class
►CEigen::TensorBase< TensorReverseOp< ReverseDimensions, XprType >, WriteAccessors >
CEigen::TensorReverseOp< ReverseDimensions, XprType >	Tensor reverse elements class
►CEigen::TensorBase< TensorRollOp< RollDimensions, XprType >, WriteAccessors >
CEigen::TensorRollOp< RollDimensions, XprType >	Tensor roll (circular shift) elements class
►CEigen::TensorBase< TensorScanOp< Op, XprType >, ReadOnlyAccessors >
CEigen::TensorScanOp< Op, XprType >	Tensor scan class
CEigen::TensorBase< TensorSelectOp< IfXprType, ThenXprType, ElseXprType >, ReadOnlyAccessors >
►CEigen::TensorBase< TensorShufflingOp< Shuffle, XprType > >
CEigen::TensorShufflingOp< Shuffle, XprType >	Tensor shuffling class
CEigen::TensorBase< TensorSlicingOp< StartIndices, Sizes, XprType > >
►CEigen::TensorBase< TensorStridingOp< Strides, XprType > >
CEigen::TensorStridingOp< Strides, XprType >	Tensor striding class
CEigen::TensorBase< TensorStridingSlicingOp< StartIndices, StopIndices, Strides, XprType > >
►CEigen::TensorBase< TensorTraceOp< Dims, XprType > >
CEigen::TensorTraceOp< Dims, XprType >	Tensor Trace class
►CEigen::TensorBase< TensorVolumePatchOp< Planes, Rows, Cols, XprType >, ReadOnlyAccessors >
CEigen::TensorVolumePatchOp< Planes, Rows, Cols, XprType >	Patch extraction specialized for processing of volumetric data. This assumes that the input has at least 4 dimensions ordered as follows:
CEigen::TensorSycl::internal::TensorContractionKernel< OutScalar, LhsScalar, RhsScalar, OutAccessor, LhsMapper, RhsMapper, StorageIndex, Properties, TripleDim, Vectorizable, input_mapper_properties, IsFinal, contraction_tp >	TensorContractionKernel is a template class that provides Tensor -Tensor contraction operation
CEigen::TensorCostModel< Device >	A cost model used to limit the number of threads used for evaluating tensor expressions
CEigen::TensorDevice< ExpressionType, DeviceType >	Pseudo expression providing an operator = that will evaluate its argument on the specified computing 'device' (GPU, thread pool, ...)
CEigen::TensorEvaluator< Derived, Device >	The tensor evaluator class
CEigen::TensorEvaluator< const TensorMap< const Tensor< Scalar, 1, Layout, Index > >, Device >
CEigen::internal::TensorExecutor< Expression, Device, Vectorizable, Tiling >	The tensor executor class
CEigen::internal::TensorExecutor< Expression, DefaultDevice, true, TiledEvaluation::Off >
CEigen::internal::TensorExecutor< Expression, DefaultDevice, Vectorizable, TiledEvaluation::On >
CTensorPairReducerOp	Converts to Tensor<Pair<Index, Scalar> > and reduces to Tensor<Index>
CTensorSlicing	Tensor slicing class
CEigen::TensorSycl::internal::ThreadProperties< StorageIndex >	ThreadProperties is a template class that provides each thread's properties within a workgroup. Please see the sycl-1.2.1 specification (https://www.khronos.org/registry/SYCL/specs/sycl-1.2.1.pdf) for the workgroup, work-items
CEigen::TensorSycl::internal::TensorContractionKernel< OutScalar, LhsScalar, RhsScalar, OutAccessor, LhsMapper, RhsMapper, StorageIndex, Properties, TripleDim, Vectorizable, input_mapper_properties, IsFinal, contraction_tp >::TiledMemory	TiledMemory: contains required memory pointer for loading each tile of the TensorContraction panel from global memory to local/private memory when local/no_local algorithm used
CEigen::gpu::TransposeView< Scalar_ >	View returned by DeviceMatrix::transpose(); maps to the cuBLAS transpose operand flag
CEigen::gpu::TriangularView< Scalar_, UpLo_ >
CEigen::gpu::TrsmExpr< Scalar_, UpLo_ >
CEigen::TensorSycl::internal::TTPanelSize< Scalar, StorageIndex, REG_SIZE_M, REG_SIZE_N, TSDK >	TTPanelSize, a template class used for setting the panel size required for launching General Tensor Tensor contraction kernel on various hardware devices
CEigen::TensorSycl::internal::TVPanelSize< Scalar, StorageIndex, NCWindow, CFactor, NCFactor >	TVPanelSize, a template class used for setting the panel size required for launching General TensorVector contraction kernel on various hardware devices
CEigen::gpu::internal::use_cusparse_bsr< BlockRows, BlockCols >