Cblaze::Abs | Generic wrapper for the abs() function |
Cblaze::Accuracy | Computation accuracy for floating point data types |
Cblaze::Acos | Generic wrapper for the acos() function |
Cblaze::Acosh | Generic wrapper for the acosh() function |
Cblaze::Add | Generic wrapper for the addition operator |
Cblaze::AddAssign | Generic wrapper for addition assignment |
Cblaze::AddConst< T > | Addition of a top level 'const' qualifier |
Cblaze::AddCV< T > | Addition of a top level 'const' and 'volatile' qualifier |
Cblaze::AddLValueReference< T > | Addition of a top level reference |
Cblaze::AddPointer< T > | Addition of a top level pointer |
Cblaze::AddRValueReference< T > | Addition of a top level reference |
Cblaze::AddVolatile< T > | Addition of a top level 'volatile' qualifier |
Cblaze::AlignedAllocator< T > | Allocator for type-specific aligned memory |
Cblaze::AlignedArray< Type, N, Alignment > | Implementation of a static array with a fixed alignment |
Cblaze::AlignedArray< Type, M *NN, Alignment > | |
Cblaze::AlignedArray< Type, NN, Alignment > | |
►Cstd::allocator< T > | STL class |
Cblaze::SmallArray< T, N, A > | Implementation of a dynamic array with small array optimization |
Cblaze::And | Generic wrapper for the logical AND operator |
Cblaze::AndAssign | Generic wrapper for bitwise AND assignment |
Cblaze::Append< TL, T > | Appending a type to a type list |
Cblaze::Archive< Stream > | Binary archive for the portable serialization of data |
Cblaze::Arg | Generic wrapper for the arg() function |
Cblaze::ArrayDelete | Array-delete policy class |
Cblaze::Asin | Generic wrapper for the asin() function |
Cblaze::Asinh | Generic wrapper for the asinh() function |
Cblaze::Assign | Generic wrapper for plain assignment |
Cblaze::Atan | Generic wrapper for the atan() function |
Cblaze::Atan2 | Generic wrapper for the atan2() function |
Cblaze::Atanh | Generic wrapper for the atanh() function |
Cblaze::BandData< CBAs > | Auxiliary class template for the data members of the Band class |
Cblaze::Bind1st< OP, A1 > | Generic wrapper for an operation with fixed 1st argument |
Cblaze::Bind2nd< OP, A2 > | Generic wrapper for an operation with fixed 2nd argument |
Cblaze::Bind3rd< OP, A3 > | Generic wrapper for an operation with fixed 3rd argument |
Cblaze::Bitand | Generic wrapper for the bitwise AND ('&') operator |
Cblaze::Bitor | Generic wrapper for the bitwise OR ('|') operator |
Cblaze::Bitxor | Generic wrapper for the bitwise XOR ('^') operator |
Cblaze::MemoryPool< Type, Blocksize >::Block | Memory block within the memory bool |
Cblaze::Bools<... > | Auxiliary tool for unwrapping a pack of variadic boolean values |
Cblaze::Cbrt | Generic wrapper for the cbrt() function |
Cblaze::Ceil | Generic wrapper for the ceil() function |
Cblaze::Clamp | Generic wrapper for the clamp() function |
Cblaze::Clear | Generic wrapper for the clear() function |
Cblaze::ColumnData< CCAs > | Auxiliary class template for the data members of the Column class |
Cblaze::CommonType< T > | Deduction of a type common to several types |
Ccomplex | Complex data type of the Blaze library |
Cblaze::ComplexProxy< PT, CT > | Proxy backend for complex types |
Cblaze::Conj | Generic wrapper for the conj() function |
Cblaze::DMatDMatAddExpr< MT1, MT2, SO >::ConstIterator | Iterator over the elements of the dense matrix |
Cblaze::DMatDMatMapExpr< MT1, MT2, OP, SO >::ConstIterator | Iterator over the elements of the dense matrix map expression |
Cblaze::DMatDMatSchurExpr< MT1, MT2, SO >::ConstIterator | Iterator over the elements of the dense matrix |
Cblaze::DMatDMatSubExpr< MT1, MT2, SO >::ConstIterator | Iterator over the elements of the dense matrix |
Cblaze::DMatGenExpr< MT, OP, SO >::ConstIterator | Iterator over the elements of the dense matrix generator expression |
Cblaze::DMatMapExpr< MT, OP, SO >::ConstIterator | Iterator over the elements of the dense matrix map expression |
Cblaze::DMatReduceExpr< MT, OP, rowwise >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::DMatScalarDivExpr< MT, ST, SO >::ConstIterator | Iterator over the elements of the dense matrix |
Cblaze::DMatScalarMultExpr< MT, ST, SO >::ConstIterator | Iterator over the elements of the dense matrix |
Cblaze::DVecDVecAddExpr< VT1, VT2, TF >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::DVecDVecCrossExpr< VT1, VT2, TF >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::DVecDVecDivExpr< VT1, VT2, TF >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::DVecDVecMapExpr< VT1, VT2, OP, TF >::ConstIterator | Iterator over the elements of the dense vector map expression |
Cblaze::DVecDVecMultExpr< VT1, VT2, TF >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::DVecDVecOuterExpr< VT1, VT2, OP >::ConstIterator | Iterator over the elements of the dense vector outer map expression |
Cblaze::DVecDVecSubExpr< VT1, VT2, TF >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::DVecGenExpr< VT, OP, TF >::ConstIterator | Iterator over the elements of the dense vector generator expression |
Cblaze::DVecMapExpr< VT, OP, TF >::ConstIterator | Iterator over the elements of the dense vector map expression |
Cblaze::DVecScalarDivExpr< VT, ST, TF >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::DVecScalarMultExpr< VT, ST, TF >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::DVecSVecMultExpr< VT1, VT2, TF >::ConstIterator | Iterator over the elements of the dense vector-sparse vector multiplication expression |
Cblaze::DVecSVecOuterExpr< VT1, VT2 >::ConstIterator | Iterator over the elements of the dense vector-sparse vector outer product expression |
Cblaze::IdentityMatrix< Type, SO, Tag >::ConstIterator | Iterator over the elements of the identity matrix |
Cblaze::SMatDMatSchurExpr< MT1, MT2 >::ConstIterator | Iterator over the elements of the sparse matrix/dense matrix Schur product expression |
Cblaze::SMatMapExpr< MT, OP, SO >::ConstIterator | Iterator over the elements of the sparse matrix map expression |
Cblaze::SMatReduceExpr< MT, OP, rowwise >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::SMatScalarDivExpr< MT, ST, SO >::ConstIterator | Iterator over the elements of the sparse matrix/scalar division expression |
Cblaze::SMatScalarMultExpr< MT, ST, SO >::ConstIterator | Iterator over the elements of the sparse matrix/scalar multiplication expression |
Cblaze::SMatVarExpr< MT, rowwise >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::SVecDVecDivExpr< VT1, VT2, TF >::ConstIterator | Iterator over the elements of the sparse vector-dense vector division expression |
Cblaze::SVecDVecMultExpr< VT1, VT2, TF >::ConstIterator | Iterator over the elements of the sparse vector-dense vector multiplication expression |
Cblaze::SVecDVecOuterExpr< VT1, VT2 >::ConstIterator | Iterator over the elements of the sparse vector-dense vector outer product expression |
Cblaze::SVecMapExpr< VT, OP, TF >::ConstIterator | Iterator over the elements of the sparse vector map expression |
Cblaze::SVecScalarDivExpr< VT, ST, TF >::ConstIterator | Iterator over the elements of the sparse vector/scalar multiplication expression |
Cblaze::SVecScalarMultExpr< VT, ST, TF >::ConstIterator | Iterator over the elements of the sparse vector/scalar multiplication expression |
Cblaze::TSMatDMatSchurExpr< MT1, MT2 >::ConstIterator | Iterator over the elements of the sparse matrix/dense matrix Schur product expression |
Cblaze::Contains< TL, T > | Searching a type list |
Cblaze::ContainsRelated< TL, T > | Searching a type list |
Cblaze::Cos | Generic wrapper for the cos() function |
Cblaze::Cosh | Generic wrapper for the cosh() function |
Cblaze::timing::CpuPolicy | Timing policy for the measurement of the CPU time |
Cblaze::CTrans | Generic wrapper for the ctrans() function |
Cblaze::CustomOppositeType< T > | Evaluation of the custom opposite type |
Cblaze::CustomTransposeType< T > | Evaluation of the custom transpose type |
Cblaze::Deallocate | Deallocate policy class |
Cblaze::Decay< T > | Applies the type conversions for by-value function arguments |
Cblaze::DeclDiag | Generic wrapper for the decldiag() function |
Cblaze::DeclHerm | Generic wrapper for the declherm() function |
Cblaze::DeclId | Generic wrapper for the declid() function |
Cblaze::DeclLow | Generic wrapper for the decllow() function |
Cblaze::DeclStrLow | Generic wrapper for the declstrlow() function |
Cblaze::DeclStrUpp | Generic wrapper for the declstrupp() function |
Cblaze::DeclSym | Generic wrapper for the declsym() function |
Cblaze::DeclUniLow | Generic wrapper for the declunilow() function |
Cblaze::DeclUniUpp | Generic wrapper for the decluniupp() function |
Cblaze::DeclUpp | Generic wrapper for the declupp() function |
►Cdecltype evalAddTrait std::declval | |
Cblaze::AddTrait< T1, T2, typename > | Base template for the AddTrait class |
►Cdecltype evalBandTrait std::declval | |
Cblaze::BandTrait< MT, CBAs > | Base template for the BandTrait class |
►Cdecltype evalColumnsTrait std::declval | |
Cblaze::ColumnsTrait< MT, N > | Base template for the ColumnsTrait class |
►Cdecltype evalColumnTrait std::declval | |
Cblaze::ColumnTrait< MT, CCAs > | Base template for the ColumnTrait class |
►Cdecltype evalCrossTrait std::declval | |
Cblaze::CrossTrait< T1, T2, typename > | Base template for the CrossTrait class |
►Cdecltype evalDeclDiagTrait std::declval | |
Cblaze::DeclDiagTrait< MT > | Base template for the DeclDiagTrait class |
►Cdecltype evalDeclHermTrait std::declval | |
Cblaze::DeclHermTrait< MT > | Base template for the DeclHermTrait class |
►Cdecltype evalDeclIdTrait std::declval | |
Cblaze::DeclIdTrait< MT > | Base template for the DeclIdTrait class |
►Cdecltype evalDeclLowTrait std::declval | |
Cblaze::DeclLowTrait< MT > | Base template for the DeclLowTrait class |
►Cdecltype evalDeclStrLowTrait std::declval | |
Cblaze::DeclStrLowTrait< MT > | Base template for the DeclStrLowTrait class |
►Cdecltype evalDeclStrUppTrait std::declval | |
Cblaze::DeclStrUppTrait< MT > | Base template for the DeclStrUppTrait class |
►Cdecltype evalDeclSymTrait std::declval | |
Cblaze::DeclSymTrait< MT > | Base template for the DeclSymTrait class |
►Cdecltype evalDeclUniLowTrait std::declval | |
Cblaze::DeclUniLowTrait< MT > | Base template for the DeclUniLowTrait class |
►Cdecltype evalDeclUniUppTrait std::declval | |
Cblaze::DeclUniUppTrait< MT > | Base template for the DeclUniUppTrait class |
►Cdecltype evalDeclUppTrait std::declval | |
Cblaze::DeclUppTrait< MT > | Base template for the DeclUppTrait class |
►Cdecltype evalDeclZeroTrait std::declval | |
Cblaze::DeclZeroTrait< T > | Base template for the DeclZeroTrait class |
►Cdecltype evalDivTrait std::declval | |
Cblaze::DivTrait< T1, T2, typename > | Base template for the DivTrait class |
►Cdecltype evalElementsTrait std::declval | |
Cblaze::ElementsTrait< VT, N > | Base template for the ElementsTrait class |
►Cdecltype evalExpandTrait std::declval | |
Cblaze::ExpandTrait< T, CEAs > | Base template for the ExpandTrait class |
►Cdecltype evalKronTrait std::declval | |
Cblaze::KronTrait< T1, T2, typename > | Base template for the KronTrait class |
►Cdecltype evalMapTrait std::declval | |
Cblaze::MapTrait< Args > | Base template for the MapTrait class |
►Cdecltype evalMultTrait std::declval | |
Cblaze::MultTrait< T1, T2, typename > | Base template for the MultTrait class |
►Cdecltype evalReduceTrait std::declval | |
Cblaze::ReduceTrait< T, OP, RF > | Base template for the ReduceTrait class |
►Cdecltype evalRepeatTrait std::declval | |
Cblaze::RepeatTrait< T, CRAs > | Base template for the RepeatTrait class |
►Cdecltype evalRowsTrait std::declval | |
Cblaze::RowsTrait< MT, M > | Base template for the RowsTrait class |
►Cdecltype evalRowTrait std::declval | |
Cblaze::RowTrait< MT, CRAs > | Base template for the RowTrait class |
►Cdecltype evalSchurTrait std::declval | |
Cblaze::SchurTrait< T1, T2, typename > | Base template for the SchurTrait class |
►Cdecltype evalSolveTrait std::declval | |
Cblaze::SolveTrait< T1, T2, typename > | Base template for the SolveTrait class |
►Cdecltype evalSubmatrixTrait std::declval | |
Cblaze::SubmatrixTrait< MT, CSAs > | Base template for the SubmatrixTrait class |
►Cdecltype evalSubTrait std::declval | |
Cblaze::SubTrait< T1, T2, typename > | Base template for the SubTrait class |
►Cdecltype evalSubvectorTrait std::declval | |
Cblaze::SubvectorTrait< VT, CSAs > | Base template for the SubvectorTrait class |
►Cdecltype isAddExpr_backend std::declval | |
Cblaze::IsAddExpr< T > | Compile time check whether the given type is an addition expression template |
►Cdecltype isBinaryMapExpr_backend std::declval | |
Cblaze::IsBinaryMapExpr< T > | Compile time check whether the given type is a binary map expression template |
►Cdecltype isColumnMajorMatrix_backend std::declval | |
Cblaze::IsColumnMajorMatrix< T > | Compile time check for column-major matrix types |
►Cdecltype isColumnVector_backend std::declval | |
Cblaze::IsColumnVector< T > | Compile time check for column vector types |
►Cdecltype isCrossExpr_backend std::declval | |
Cblaze::IsCrossExpr< T > | Compile time check whether the given type is a cross product expression template |
►Cdecltype isDeclaration_backend std::declval | |
Cblaze::IsDeclaration< T > | Compile time check whether the given type is a declaration expression template |
►Cdecltype isDeclDiagExpr_backend std::declval | |
Cblaze::IsDeclDiagExpr< T > | Compile time check whether the given type is a decldiag expression template |
►Cdecltype isDeclExpr_backend std::declval | |
Cblaze::IsDeclExpr< T > | Compile time check whether the given type is a declaration expression template |
►Cdecltype isDeclHermExpr_backend std::declval | |
Cblaze::IsDeclHermExpr< T > | Compile time check whether the given type is a declherm expression template |
►Cdecltype isDeclLowExpr_backend std::declval | |
Cblaze::IsDeclLowExpr< T > | Compile time check whether the given type is a decllow expression template |
►Cdecltype isDeclStrLowExpr_backend std::declval | |
Cblaze::IsDeclStrLowExpr< T > | Compile time check whether the given type is a declstrlow expression template |
►Cdecltype isDeclStrUppExpr_backend std::declval | |
Cblaze::IsDeclStrUppExpr< T > | Compile time check whether the given type is a declstrupp expression template |
►Cdecltype isDeclSymExpr_backend std::declval | |
Cblaze::IsDeclSymExpr< T > | Compile time check whether the given type is a declsym expression template |
►Cdecltype isDeclUniLowExpr_backend std::declval | |
Cblaze::IsDeclUniLowExpr< T > | Compile time check whether the given type is a declunilow expression template |
►Cdecltype isDeclUniUppExpr_backend std::declval | |
Cblaze::IsDeclUniUppExpr< T > | Compile time check whether the given type is a decluniupp expression template |
►Cdecltype isDeclUppExpr_backend std::declval | |
Cblaze::IsDeclUppExpr< T > | Compile time check whether the given type is a declupp expression template |
►Cdecltype isDenseMatrix_backend std::declval | |
Cblaze::IsDenseMatrix< T > | Compile time check for dense matrix types |
►Cdecltype isDenseVector_backend std::declval | |
Cblaze::IsDenseVector< T > | Compile time check for dense vector types |
►Cdecltype isDivExpr_backend std::declval | |
Cblaze::IsDivExpr< T > | Compile time check whether the given type is a division expression template |
►Cdecltype isEigenExpr_backend std::declval | |
Cblaze::IsEigenExpr< T > | Compile time check whether the given type is an eigenvalue expression template |
►Cdecltype isEvalExpr_backend std::declval | |
Cblaze::IsEvalExpr< T > | Compile time check whether the given type is an evaluation expression template |
►Cdecltype isExpandExpr_backend std::declval | |
Cblaze::IsExpandExpr< T > | Compile time check whether the given type is an expansion expression template |
►Cdecltype isExpression_backend std::declval | |
Cblaze::IsExpression< T > | Compile time check whether the given type is an expression template |
►Cdecltype isGenExpr_backend std::declval | |
Cblaze::IsGenExpr< T > | Compile time check whether the given type is a generator expression template |
►Cdecltype isKronExpr_backend std::declval | |
Cblaze::IsKronExpr< T > | Compile time check whether the given type is a Kronecker product expression template |
►Cdecltype isMatEvalExpr_backend std::declval | |
Cblaze::IsMatEvalExpr< T > | Compile time check whether the given type is a matrix evaluation expression template |
►Cdecltype isMatExpExpr_backend std::declval | |
Cblaze::IsMatExpExpr< T > | Compile time check whether the given type is a matrix exponential expression template |
►Cdecltype isMatGenExpr_backend std::declval | |
Cblaze::IsMatGenExpr< T > | Compile time check whether the given type is a matrix generator expression template |
►Cdecltype isMatInvExpr_backend std::declval | |
Cblaze::IsMatInvExpr< T > | Compile time check whether the given type is a matrix inversion expression template |
►Cdecltype isMatMapExpr_backend std::declval | |
Cblaze::IsMatMapExpr< T > | Compile time check whether the given type is a unary matrix map expression template |
►Cdecltype isMatMatAddExpr_backend std::declval | |
Cblaze::IsMatMatAddExpr< T > | Compile time check whether the given type is a matrix/matrix addition expression template |
►Cdecltype isMatMatKronExpr_backend std::declval | |
Cblaze::IsMatMatKronExpr< T > | Compile time check whether the given type is a matrix/matrix Kronecker product expression template |
►Cdecltype isMatMatMapExpr_backend std::declval | |
Cblaze::IsMatMatMapExpr< T > | Compile time check whether the given type is a binary matrix map expression template |
►Cdecltype isMatMatMultExpr_backend std::declval | |
Cblaze::IsMatMatMultExpr< T > | Compile time check whether the given type is a matrix/matrix multiplication expression template |
►Cdecltype isMatMatSolveExpr_backend std::declval | |
Cblaze::IsMatMatSolveExpr< T > | Compile time check whether the given type is a multi LSE solver expression template |
►Cdecltype isMatMatSubExpr_backend std::declval | |
Cblaze::IsMatMatSubExpr< T > | Compile time check whether the given type is a matrix/matrix subtraction expression template |
►Cdecltype isMatNoAliasExpr_backend std::declval | |
Cblaze::IsMatNoAliasExpr< T > | Compile time check whether the given type is a matrix no-alias expression template |
►Cdecltype isMatNoSIMDExpr_backend std::declval | |
Cblaze::IsMatNoSIMDExpr< T > | Compile time check whether the given type is a matrix no-SIMD expression template |
►Cdecltype isMatReduceExpr_backend std::declval | |
Cblaze::IsMatReduceExpr< T > | Compile time check whether the given type is a reduction expression template |
►Cdecltype isMatRepeatExpr_backend std::declval | |
Cblaze::IsMatRepeatExpr< T > | Compile time check whether the given type is a matrix repeater expression template |
►Cdecltype isMatrix_backend std::declval | |
Cblaze::IsMatrix< T > | Compile time check for matrix types |
►Cdecltype isMatScalarDivExpr_backend std::declval | |
Cblaze::IsMatScalarDivExpr< T > | Compile time check whether the given type is a matrix/scalar division expression template |
►Cdecltype isMatScalarMultExpr_backend std::declval | |
Cblaze::IsMatScalarMultExpr< T > | Compile time check whether the given type is a matrix/scalar multiplication expression template |
►Cdecltype isMatSerialExpr_backend std::declval | |
Cblaze::IsMatSerialExpr< T > | Compile time check whether the given type is a matrix serial evaluation expression template |
►Cdecltype isMatTransExpr_backend std::declval | |
Cblaze::IsMatTransExpr< T > | Compile time check whether the given type is a matrix transposition expression template |
►Cdecltype isMatVecMultExpr_backend std::declval | |
Cblaze::IsMatVecMultExpr< T > | Compile time check whether the given type is a matrix/vector multiplication expression template |
►Cdecltype isMatVecSolveExpr_backend std::declval | |
Cblaze::IsMatVecSolveExpr< T > | Compile time check whether the given type is a single LSE solver expression template |
►Cdecltype isModification std::declval | |
Cblaze::IsModification< T > | Compile time check whether the given type is a modification expression template |
►Cdecltype isMultExpr_backend std::declval | |
Cblaze::IsMultExpr< T > | Compile time check whether the given type is a multiplication expression template |
►Cdecltype isNoAliasExpr_backend std::declval | |
Cblaze::IsNoAliasExpr< T > | Compile time check whether the given type is a no-alias expression template |
►Cdecltype isNoSIMDExpr_backend std::declval | |
Cblaze::IsNoSIMDExpr< T > | Compile time check whether the given type is a no-SIMD expression template |
►Cdecltype isProxy_backend std::declval | |
Cblaze::IsProxy< T > | Compile time check for proxy types |
►Cdecltype isReduceExpr_backend std::declval | |
Cblaze::IsReduceExpr< T > | Compile time check whether the given type is a reduction expression template |
►Cdecltype isRepeatExpr_backend std::declval | |
Cblaze::IsRepeatExpr< T > | Compile time check whether the given type is a repeater expression template |
►Cdecltype isRowMajorMatrix_backend std::declval | |
Cblaze::IsRowMajorMatrix< T > | Compile time check for row-major matrix types |
►Cdecltype isRowVector_backend std::declval | |
Cblaze::IsRowVector< T > | Compile time check for row vector types |
►Cdecltype isSchurExpr_backend std::declval | |
Cblaze::IsSchurExpr< T > | Compile time check whether the given type is a Schur product expression template |
►Cdecltype isSerialExpr_backend std::declval | |
Cblaze::IsSerialExpr< T > | Compile time check whether the given type is a serial evaluation expression template |
►Cdecltype isSIMDPack_backend std::declval | |
Cblaze::IsSIMDPack< T > | Compile time check for SIMD data types |
►Cdecltype isSolveExpr_backend std::declval | |
Cblaze::IsSolveExpr< T > | Compile time check whether the given type is a solver expression template |
►Cdecltype isSparseMatrix_backend std::declval | |
Cblaze::IsSparseMatrix< T > | Compile time check for sparse matrix types |
►Cdecltype isSparseVector_backend std::declval | |
Cblaze::IsSparseVector< T > | Compile time check for sparse vector types |
►Cdecltype isSubExpr_backend std::declval | |
Cblaze::IsSubExpr< T > | Compile time check whether the given type is a subtraction expression template |
►Cdecltype isSVDExpr_backend std::declval | |
Cblaze::IsSVDExpr< T > | Compile time check whether the given type is a singular value expression template |
►Cdecltype isTransExpr_backend std::declval | |
Cblaze::IsTransExpr< T > | Compile time check whether the given type is a transposition expression template |
►Cdecltype isTVecMatMultExpr_backend std::declval | |
Cblaze::IsTVecMatMultExpr< T > | Compile time check whether the given type is a vector/matrix multiplication expression template |
►Cdecltype isUnaryMapExpr_backend std::declval | |
Cblaze::IsUnaryMapExpr< T > | Compile time check whether the given type is a unary map expression template |
►Cdecltype isVecEvalExpr_backend std::declval | |
Cblaze::IsVecEvalExpr< T > | Compile time check whether the given type is a vector evaluation expression template |
►Cdecltype isVecExpandExpr_backend std::declval | |
Cblaze::IsVecExpandExpr< T > | Compile time check whether the given type is a vector expansion expression template |
►Cdecltype isVecGenExpr_backend std::declval | |
Cblaze::IsVecGenExpr< T > | Compile time check whether the given type is a vector generator expression template |
►Cdecltype isVecMapExpr_backend std::declval | |
Cblaze::IsVecMapExpr< T > | Compile time check whether the given type is a unary vector map expression template |
►Cdecltype isVecNoAliasExpr_backend std::declval | |
Cblaze::IsVecNoAliasExpr< T > | Compile time check whether the given type is a vector no-alias expression template |
►Cdecltype isVecNoSIMDExpr_backend std::declval | |
Cblaze::IsVecNoSIMDExpr< T > | Compile time check whether the given type is a vector no-SIMD expression template |
►Cdecltype isVecRepeatExpr_backend std::declval | |
Cblaze::IsVecRepeatExpr< T > | Compile time check whether the given type is a vector repeater expression template |
►Cdecltype isVecScalarDivExpr_backend std::declval | |
Cblaze::IsVecScalarDivExpr< T > | Compile time check whether the given type is a vector/scalar division expression template |
►Cdecltype isVecScalarMultExpr_backend std::declval | |
Cblaze::IsVecScalarMultExpr< T > | Compile time check whether the given type is a vector/scalar multiplication expression template |
►Cdecltype isVecSerialExpr_backend std::declval | |
Cblaze::IsVecSerialExpr< T > | Compile time check whether the given type is a vector serial evaluation expression template |
►Cdecltype isVector_backend std::declval | |
Cblaze::IsVector< T > | Compile time check for vector types |
►Cdecltype isVecTransExpr_backend std::declval | |
Cblaze::IsVecTransExpr< T > | Compile time check whether the given type is a vector transposition expression template |
►Cdecltype isVecTVecMapExpr_backend std::declval | |
Cblaze::IsVecTVecMapExpr< T > | Compile time check whether the given type is an outer map expression template |
►Cdecltype isVecTVecMultExpr_backend std::declval | |
Cblaze::IsVecTVecMultExpr< T > | Compile time check whether the given type is an outer product expression template |
►Cdecltype isVecVecAddExpr_backend std::declval | |
Cblaze::IsVecVecAddExpr< T > | Compile time check whether the given type is a vector/vector addition expression template |
►Cdecltype isVecVecDivExpr_backend std::declval | |
Cblaze::IsVecVecDivExpr< T > | Compile time check whether the given type is a vector/vector division expression template |
►Cdecltype isVecVecKronExpr_backend std::declval | |
Cblaze::IsVecVecKronExpr< T > | Compile time check whether the given type is a vector/vector Kronecker product expression template |
►Cdecltype isVecVecMapExpr_backend std::declval | |
Cblaze::IsVecVecMapExpr< T > | Compile time check whether the given type is a binary vector map expression template |
►Cdecltype isVecVecMultExpr_backend std::declval | |
Cblaze::IsVecVecMultExpr< T > | Compile time check whether the given type is a vector/vector multiplication expression template |
►Cdecltype isVecVecSubExpr_backend std::declval | |
Cblaze::IsVecVecSubExpr< T > | Compile time check whether the given type is a vector/vector subtraction expression template |
►Cdecltype isView_backend std::declval | |
Cblaze::IsView< T > | Compile time check for views |
►Cstd::declval | |
Cblaze::AddTrait< T1, T2, typename > | Base template for the AddTrait class |
Cblaze::CrossTrait< T1, T2, typename > | Base template for the CrossTrait class |
Cblaze::DivTrait< T1, T2, typename > | Base template for the DivTrait class |
Cblaze::KronTrait< T1, T2, typename > | Base template for the KronTrait class |
Cblaze::MultTrait< T1, T2, typename > | Base template for the MultTrait class |
Cblaze::ReduceTrait< T, OP, RF > | Base template for the ReduceTrait class |
Cblaze::SchurTrait< T1, T2, typename > | Base template for the SchurTrait class |
Cblaze::SolveTrait< T1, T2, typename > | Base template for the SolveTrait class |
Cblaze::SubTrait< T1, T2, typename > | Base template for the SubTrait class |
Cblaze::DeclZero | Generic wrapper for the declzero() function |
Cblaze::DefaultDelete< Type > | Default C++ deletion policy class |
Cblaze::DefaultProxy< PT, RT > | Default proxy backend for built-in and alternate user-specific class types |
Cblaze::DenseIterator< Type, AF > | Implementation of a generic iterator for dense vectors and matrices |
Cblaze::Dependency< T > | Lifetime dependency on a singleton object |
Cblaze::DerestrictTrait< T > | Evaluation of the return type of the derestrict function |
Cblaze::DiagonalMatrix< MT, SO, DF > | Matrix adapter for diagonal matrices |
Cblaze::Div | Generic wrapper for the division operator |
Cblaze::DivAssign | Generic wrapper for division assignment |
Cblaze::DMatFixExpr< MT, SO > | Expression object for fixing the size of a dense matrix |
Cblaze::DMatReduceExpr< MT, OP, RF > | Base template for row-major dense matrix partial reduction operations |
Cblaze::DMatSMatSchurExpr< typename, typename > | |
Cblaze::DMatTSMatSchurExpr< typename, typename > | |
Cblaze::DVecFixExpr< VT, TF > | Expression object for fixing the size of a dense vector |
Cblaze::DynamicAllocator< A1, As > | Deduction of an allocator type for dynamic vectors and matrices |
Cblaze::EmptyType | Empty data type for utility purposes |
Cblaze::EnableIf< Condition, T > | Substitution Failure Is Not An Error (SFINAE) class |
Cblaze::Epsilon | Numerical epsilon value for floating point data types |
Cblaze::Erase< TL, T > | Erasing the first occurrence of a type from a type list |
Cblaze::EraseAll< TL, T > | Erasing all occurrences of a type from a type list |
Cblaze::Erf | Generic wrapper for the erf() function |
Cblaze::Erfc | Generic wrapper for the erfc() function |
Cblaze::Eval | Generic wrapper for the eval() function |
Cblaze::EvaluateTrait< T, typename > | Evaluation of the return type of the evaluate function |
Cblaze::Exp | Generic wrapper for the exp() function |
Cblaze::Exp10 | Generic wrapper for the exp10() function |
Cblaze::Exp2 | Generic wrapper for the exp2() function |
Cblaze::ExpandExprData< CEAs > | Auxiliary class template for the data members of expansion expression classes |
►Cblaze::ExpandExprData< CEAs... > | |
Cblaze::DVecExpandExpr< VT, TF, CEAs > | Expression object for dense vector expansion |
Cblaze::SVecExpandExpr< VT, TF, CEAs > | Expression object for sparse vector expansion |
Cblaze::Floor | Generic wrapper for the floor() function |
Cblaze::fortran_complex16 | Type of double precision complex numbers within a Fortran forward declaration |
Cblaze::fortran_complex8 | Type of single precision complex numbers within a Fortran forward declaration |
Cblaze::MemoryPool< Type, Blocksize >::FreeObject | A single element of the free list of the memory pool |
Cblaze::FunctionTrace | RAII object for function tracing |
Cblaze::Greater | Generic wrapper for the greater-than relational operator |
Cblaze::GroupTag< ID > | Group tag for vectors and matrices |
►CHasAbsHelper | |
Cblaze::HasAbs< T, typename > | Availability of the abs() operation for the given data types |
►CHasAcosHelper | |
Cblaze::HasAcos< T, typename > | Availability of the acos() operation for the given data types |
►CHasAcoshHelper | |
Cblaze::HasAcosh< T, typename > | Availability of the acosh() operation for the given data types |
►CHasAddHelper | |
Cblaze::HasAdd< T1, T2, typename > | Availability of an addition operator for the given data types |
►CHasAsinHelper | |
Cblaze::HasAsin< T, typename > | Availability of the asin() operation for the given data types |
►CHasAsinhHelper | |
Cblaze::HasAsinh< T, typename > | Availability of the asinh() operation for the given data types |
►CHasAtan2Helper | |
Cblaze::HasAtan2< T1, T2, typename > | Availability of the atan2() operation for the given data types |
►CHasAtanHelper | |
Cblaze::HasAtan< T, typename > | Availability of the atan() operation for the given data types |
►CHasAtanhHelper | |
Cblaze::HasAtanh< T, typename > | Availability of the atanh() operation for the given data types |
►CHasCbrtHelper | |
Cblaze::HasCbrt< T, typename > | Availability of the cbrt() operation for the given data types |
►CHasCeilHelper | |
Cblaze::HasCeil< T, typename > | Availability of the ceil() operation for the given data types |
►CHasClampHelper | |
Cblaze::HasClamp< T, typename > | Availability of the clamp() operation for the given data types |
►CHasConjHelper | |
Cblaze::HasConj< T, typename > | Availability of the conj() operation for the given data types |
►CHasCosHelper | |
Cblaze::HasCos< T, typename > | Availability of the cos() operation for the given data types |
►CHasCoshHelper | |
Cblaze::HasCosh< T, typename > | Availability of the cosh() operation for the given data types |
Cblaze::HasCyclicDependency< T, TL, C > | |
►CHasDivHelper | |
Cblaze::HasDiv< T1, T2, typename > | Availability of a division operator for the given data types |
►CHasErfcHelper | |
Cblaze::HasErfc< T, typename > | Availability of the erfc() operation for the given data types |
►CHasErfHelper | |
Cblaze::HasErf< T, typename > | Availability of the erf() operation for the given data types |
►CHasExp10Helper | |
Cblaze::HasExp10< T, typename > | Availability of the exp10() operation for the given data types |
►CHasExp2Helper | |
Cblaze::HasExp2< T, typename > | Availability of the exp2() operation for the given data types |
►CHasExpHelper | |
Cblaze::HasExp< T, typename > | Availability of the exp() operation for the given data types |
►CHasFloorHelper | |
Cblaze::HasFloor< T, typename > | Availability of the floor() operation for the given data types |
►CHasHypotHelper | |
Cblaze::HasHypot< T1, T2, typename > | Availability of the hypot() operation for the given data types |
►CHasImagHelper | |
Cblaze::HasImag< T, typename > | Availability of the imag() operation for the given data types |
►CHasInvCbrtHelper | |
Cblaze::HasInvCbrt< T, typename > | Availability of the invcbrt() operation for the given data types |
►CHasInvSqrtHelper | |
Cblaze::HasInvSqrt< T, typename > | Availability of the invsqrt() operation for the given data types |
►CHasLGammaHelper | |
Cblaze::HasLGamma< T, typename > | Availability of the lgamma() operation for the given data types |
►CHasLog10Helper | |
Cblaze::HasLog10< T, typename > | Availability of the log10() operation for the given data types |
►CHasLog1pHelper | |
Cblaze::HasLog1p< T, typename > | Availability of the log1p() operation for the given data types |
►CHasLog2Helper | |
Cblaze::HasLog2< T, typename > | Availability of the log2() operation for the given data types |
►CHasLogHelper | |
Cblaze::HasLog< T, typename > | Availability of the log() operation for the given data types |
►CHasMaxHelper | |
Cblaze::HasMax< T1, T2, typename > | Availability of a max() operation for the given data types |
►CHasMinHelper | |
Cblaze::HasMin< T1, T2, typename > | Availability of a min() operation for the given data types |
►CHasMultHelper | |
Cblaze::HasMult< T1, T2, typename > | Availability of a multiplication operator for the given data types |
►CHasPowHelper | |
Cblaze::HasPow< T1, T2, typename > | Availability of the pow() operation for the given data types |
►CHasRealHelper | |
Cblaze::HasReal< T, typename > | Availability of the real() operation for the given data types |
►CHasRoundHelper | |
Cblaze::HasRound< T, typename > | Availability of the round() operation for the given data types |
►CHasSignHelper | |
Cblaze::HasSign< T, typename > | Availability of the sign() operation for the given data types |
►CHasSinHelper | |
Cblaze::HasSin< T, typename > | Availability of the sin() operation for the given data types |
►CHasSinhHelper | |
Cblaze::HasSinh< T, typename > | Availability of the sinh() operation for the given data types |
►CHasSqrtHelper | |
Cblaze::HasSqrt< T, typename > | Availability of the sqrt() operation for the given data types |
►CHasSubHelper | |
Cblaze::HasSub< T1, T2, typename > | Availability of a subtraction operator for the given data types |
►CHasTanHelper | |
Cblaze::HasTan< T, typename > | Availability of the tan() operation for the given data types |
►CHasTanhHelper | |
Cblaze::HasTanh< T, typename > | Availability of the tanh() operation for the given data types |
►CHasTruncHelper | |
Cblaze::HasTrunc< T, typename > | Availability of the trunc() operation for the given data types |
Cblaze::HermitianMatrix< MT, SO, DF > | Matrix adapter for Hermitian matrices |
Cblaze::HighType< T1, T2, typename > | Base template for the HighType type trait |
Cblaze::Hypot | Generic wrapper for the hypot() function |
Cblaze::If< Condition > | Compile time type selection |
►CIf_t | |
►Cblaze::Declaration< MT > | |
Cblaze::DMatDeclDiagExpr< MT, SO > | Expression object for the explicit diagonal declaration of dense matrices |
Cblaze::DMatDeclHermExpr< MT, SO > | Expression object for the explicit Hermitian declaration of dense matrices |
Cblaze::DMatDeclLowExpr< MT, SO > | Expression object for the explicit lower declaration of dense matrices |
Cblaze::DMatDeclStrLowExpr< MT, SO > | Expression object for the explicit strictly lower declaration of dense matrices |
Cblaze::DMatDeclStrUppExpr< MT, SO > | Expression object for the explicit strictly upper declaration of dense matrices |
Cblaze::DMatDeclSymExpr< MT, SO > | Expression object for the explicit symmetry declaration of dense matrices |
Cblaze::DMatDeclUniLowExpr< MT, SO > | Expression object for the explicit unilower declaration of dense matrices |
Cblaze::DMatDeclUniUppExpr< MT, SO > | Expression object for the explicit uniupper declaration of dense matrices |
Cblaze::DMatDeclUppExpr< MT, SO > | Expression object for the explicit upper declaration of dense matrices |
Cblaze::SMatDeclDiagExpr< MT, SO > | Expression object for the explicit diagonal declaration of sparse matrices |
Cblaze::SMatDeclHermExpr< MT, SO > | Expression object for the explicit Hermitian declaration of sparse matrices |
Cblaze::SMatDeclLowExpr< MT, SO > | Expression object for the explicit lower declaration of sparse matrices |
Cblaze::SMatDeclStrLowExpr< MT, SO > | Expression object for the explicit strictly lower declaration of sparse matrices |
Cblaze::SMatDeclStrUppExpr< MT, SO > | Expression object for the explicit strictly upper declaration of sparse matrices |
Cblaze::SMatDeclSymExpr< MT, SO > | Expression object for the explicit symmetry declaration of sparse matrices |
Cblaze::SMatDeclUniLowExpr< MT, SO > | Expression object for the explicit unilower declaration of sparse matrices |
Cblaze::SMatDeclUniUppExpr< MT, SO > | Expression object for the explicit uniupper declaration of sparse matrices |
Cblaze::SMatDeclUppExpr< MT, SO > | Expression object for the explicit upper declaration of sparse matrices |
►Cblaze::Modification< MT > | |
Cblaze::DMatNoAliasExpr< MT, SO > | Expression object for the non-aliased evaluation of dense matrices |
Cblaze::DMatNoSIMDExpr< MT, SO > | Expression object for the non-SIMD evaluation of dense matrices |
Cblaze::SMatNoAliasExpr< MT, SO > | Expression object for the non-aliased evaluation of sparse matrices |
►Cblaze::Modification< VT > | |
Cblaze::DVecNoAliasExpr< VT, TF > | Expression object for the non-aliased evaluation of dense vectors |
Cblaze::DVecNoSIMDExpr< VT, TF > | Expression object for the non-SIMD evaluation of dense vectors |
Cblaze::SVecNoAliasExpr< VT, TF > | Expression object for the non-aliased evaluation of sparse vectors |
►Cblaze::Proxy< DiagonalProxy< MT >, ElementType_t< MT > > | |
Cblaze::DiagonalProxy< MT > | Access proxy for diagonal matrices |
►Cblaze::Proxy< HermitianProxy< MT > > | |
Cblaze::HermitianProxy< MT > | Access proxy for Hermitian matrices |
►Cblaze::Proxy< HermitianValue< MT > > | |
Cblaze::HermitianValue< MT > | Representation of two synchronized values within a sparse Hermitian matrix |
►Cblaze::Proxy< LowerProxy< MT >, ElementType_t< MT > > | |
Cblaze::LowerProxy< MT > | Access proxy for lower triangular matrices |
►Cblaze::Proxy< MatrixAccessProxy< MT >, ElementType_t< MT > > | |
Cblaze::MatrixAccessProxy< MT > | Access proxy for sparse, matrices |
►Cblaze::Proxy< NonScalarProxy< MT >, ValueType_t< ElementType_t< MT > > > | |
Cblaze::NonScalarProxy< MT > | Access proxy for symmetric, square matrices with non-scalar element types |
►Cblaze::Proxy< ScalarProxy< MT > > | |
Cblaze::ScalarProxy< MT > | Access proxy for symmetric, square matrices with scalar element types |
►Cblaze::Proxy< StrictlyLowerProxy< MT >, ElementType_t< MT > > | |
Cblaze::StrictlyLowerProxy< MT > | Access proxy for strictly lower triangular matrices |
►Cblaze::Proxy< StrictlyUpperProxy< MT >, ElementType_t< MT > > | |
Cblaze::StrictlyUpperProxy< MT > | Access proxy for strictly upper triangular matrices |
►Cblaze::Proxy< SymmetricValue< MT > > | |
Cblaze::SymmetricValue< MT > | Representation of two synchronized values within a sparse symmetric matrix |
►Cblaze::Proxy< UniLowerProxy< MT > > | |
Cblaze::UniLowerProxy< MT > | Access proxy for lower unitriangular matrices |
►Cblaze::Proxy< UniLowerValue< MT > > | |
Cblaze::UniLowerValue< MT > | Representation of a value within a sparse lower unitriangular matrix |
►Cblaze::Proxy< UniUpperProxy< MT > > | |
Cblaze::UniUpperProxy< MT > | Access proxy for upper unitriangular matrices |
►Cblaze::Proxy< UniUpperValue< MT > > | |
Cblaze::UniUpperValue< MT > | Representation of a value within a sparse upper unitriangular matrix |
►Cblaze::Proxy< UpperProxy< MT >, ElementType_t< MT > > | |
Cblaze::UpperProxy< MT > | Access proxy for upper triangular matrices |
►Cblaze::Proxy< VectorAccessProxy< VT >, ElementType_t< VT > > | |
Cblaze::VectorAccessProxy< VT > | Access proxy for sparse, N-dimensional vectors |
Cblaze::DMatRepeatExpr< MT, SO, CRAs > | Expression object for the dense matrix repeat() function |
Cblaze::DMatTransExpr< MT, SO > | Expression object for dense matrix transpositions |
Cblaze::DVecExpandExpr< VT, TF, CEAs > | Expression object for dense vector expansion |
Cblaze::DVecRepeatExpr< VT, TF, CRAs > | Expression object for the dense vector repeat() function |
Cblaze::DVecTransExpr< VT, TF > | Expression object for dense vector transpositions |
Cblaze::Declaration< T > | Base class for all declaration expression templates |
Cblaze::Modification< T > | Base class for all modification expression templates |
Cblaze::Proxy< PT, RT > | Proxy base class |
Cblaze::SMatRepeatExpr< MT, SO, CRAs > | Expression object for the sparse matrix repeat() function |
Cblaze::SMatTransExpr< MT, SO > | Expression object for sparse matrix transpositions |
Cblaze::SVecExpandExpr< VT, TF, CEAs > | Expression object for sparse vector expansion |
Cblaze::SVecRepeatExpr< VT, TF, CRAs > | Expression object for the sparse vector repeat() function |
Cblaze::SVecTransExpr< VT, TF > | Expression object for sparse vector transpositions |
Cblaze::Imag | Generic wrapper for the imag() function |
Cindex_sequence | Index sequence type of the Blaze library |
Cblaze::IndexOf< TL, T > | Searching a type list |
Cblaze::Indices< T > | Auxiliary class for the generation of random indices |
Cblaze::Infinity | Positive infinity for built-in data types |
Cinitializer_list | Initializer list type of the Blaze library |
Cblaze::InitializerIterator< Type > | Implementation of an iterator for (extended) initializer lists |
Cint16_t | 16-bit signed integer type of the Blaze library |
Cint32_t | 32-bit signed integer type of the Blaze library |
Cint64_t | 64-bit signed integer type of the Blaze library |
Cint8_t | 8-bit signed integer type of the Blaze library |
Cinteger_sequence | Integer sequence type of the Blaze library |
►Cstd::integral_constant | |
►Cblaze::IntegralConstant< size_t, AlignmentOfHelper< T >::value > | |
Cblaze::AlignmentOf< T > | Evaluation of the required alignment of the given data type |
►Cblaze::IntegralConstant< size_t, 0UL > | |
Cblaze::Extent< T, N > | Compile time check for the size of array bounds |
Cblaze::Rank< T > | Compile time check for array ranks |
►Cblaze::IntegralConstant< T, N > | Generic wrapper for a compile time constant integral value |
►Cblaze::HasSize< T, 1UL > | |
Cblaze::Has1Byte< T > | Compile time size check |
►Cblaze::HasSize< T, 2UL > | |
Cblaze::Has2Bytes< T > | Compile time size check |
►Cblaze::HasSize< T, 4UL > | |
Cblaze::Has4Bytes< T > | Compile time size check |
►Cblaze::HasSize< T, 8UL > | |
Cblaze::Has8Bytes< T > | Compile time size check |
Cblaze::All< TypeTrait, T1, T2, Ts > | Compile time type check |
Cblaze::AlwaysFalse< T > | Type dependent compile time false |
Cblaze::AlwaysTrue< T > | Type dependent compile time true |
Cblaze::Any< TypeTrait, T1, T2, Ts > | Compile time type check |
Cblaze::Check< C > | Template for the blaze::checked and blaze::unchecked instances |
Cblaze::HasConstDataAccess< T > | Compile time check for low-level access to constant data |
Cblaze::HasMutableDataAccess< T > | Compile time check for low-level access to mutable data |
Cblaze::HasSIMDAbs< T > | Availability of a SIMD absolute value operation for the given data type |
Cblaze::HasSIMDAcos< T > | Availability of a SIMD inverse cosine operation for the given data type |
Cblaze::HasSIMDAcosh< T > | Availability of a SIMD inverse hyperbolic cosine operation for the given data type |
Cblaze::HasSIMDAdd< T1, T2, typename > | Availability of a SIMD addition for the given data types |
Cblaze::HasSIMDAsin< T > | Availability of a SIMD inverse sine operation for the given data type |
Cblaze::HasSIMDAsinh< T > | Availability of a SIMD inverse hyperbolic sine operation for the given data type |
Cblaze::HasSIMDAtan< T > | Availability of a SIMD inverse tangent operation for the given data type |
Cblaze::HasSIMDAtan2< T1, T2 > | Availability of a SIMD inverse tangent operation for the given data types |
Cblaze::HasSIMDAtanh< T > | Availability of a SIMD inverse hyperbolic tangent operation for the given data type |
Cblaze::HasSIMDBitand< T1, T2 > | Availability of a SIMD bitwise AND ('&') for the given data types |
Cblaze::HasSIMDBitor< T1, T2 > | Availability of a SIMD bitwise OR ('|') for the given data types |
Cblaze::HasSIMDBitxor< T1, T2 > | Availability of a SIMD bitwise XOR ('^') for the given data types |
Cblaze::HasSIMDCbrt< T > | Availability of a SIMD cubic root operation for the given data type |
Cblaze::HasSIMDCeil< T > | Availability of a SIMD ceil operation for the given data type |
Cblaze::HasSIMDConj< T > | Availability of a SIMD conjugate operation for the given data type |
Cblaze::HasSIMDCos< T > | Availability of a SIMD cosine operation for the given data type |
Cblaze::HasSIMDCosh< T > | Availability of a SIMD hyperbolic cosine operation for the given data type |
Cblaze::HasSIMDDiv< T1, T2, typename > | Availability of a SIMD division for the given data types |
Cblaze::HasSIMDEqual< T1, T2, typename > | Availability of a SIMD equality comparison for the given data types |
Cblaze::HasSIMDErf< T > | Availability of a SIMD error function (erf ) operation for the given data type |
Cblaze::HasSIMDErfc< T > | Availability of a SIMD complementary error function (erfc ) operation for the given data type |
Cblaze::HasSIMDExp< T > | Availability of a SIMD exp() operation for the given data type |
Cblaze::HasSIMDExp10< T > | Availability of a SIMD exp10() operation for the given data type |
Cblaze::HasSIMDExp2< T > | Availability of a SIMD exp2() operation for the given data type |
Cblaze::HasSIMDFloor< T > | Availability of a SIMD floor operation for the given data type |
Cblaze::HasSIMDHypot< T1, T2 > | Availability of a SIMD hypotenous operation for the given data types |
Cblaze::HasSIMDInvCbrt< T > | Availability of a SIMD inverse cubic root operation for the given data type |
Cblaze::HasSIMDInvSqrt< T > | Availability of a SIMD inverse square root operation for the given data type |
Cblaze::HasSIMDLGamma< T > | Availability of a SIMD lgamma operation for the given data type |
Cblaze::HasSIMDLog< T > | Availability of a SIMD natural logarithm operation for the given data type |
Cblaze::HasSIMDLog10< T > | Availability of a SIMD common logarithm operation for the given data type |
Cblaze::HasSIMDLog1p< T > | Availability of a SIMD log1p operation for the given data type |
Cblaze::HasSIMDLog2< T > | Availability of a SIMD binary logarithm operation for the given data type |
Cblaze::HasSIMDMax< T1, T2, typename > | Availability of a SIMD max operation for the given data types |
Cblaze::HasSIMDMin< T1, T2, typename > | Availability of a SIMD min operation for the given data types |
Cblaze::HasSIMDMult< T1, T2, typename > | Availability of a SIMD multiplication for the given data types |
Cblaze::HasSIMDPow< T1, T2 > | Availability of a SIMD power operation for the given data type |
Cblaze::HasSIMDRound< T > | Availability of a SIMD round operation for the given data type |
Cblaze::HasSIMDShiftLI< T > | Availability of a SIMD uniform left-shift for the given data types |
Cblaze::HasSIMDShiftLV< T1, T2 > | Availability of an SIMD elementwise left-shift for the given data types |
Cblaze::HasSIMDShiftRI< T > | Availability of a SIMD uniform right-shift for the given data types |
Cblaze::HasSIMDShiftRV< T1, T2 > | Availability of a SIMD elementwise right-shift for the given data types |
Cblaze::HasSIMDSign< T > | Availability of a SIMD sign operation for the given data type |
Cblaze::HasSIMDSin< T > | Availability of a SIMD sine operation for the given data type |
Cblaze::HasSIMDSinh< T > | Availability of a SIMD hyperbolic sine operation for the given data type |
Cblaze::HasSIMDSqrt< T > | Availability of a SIMD square root operation for the given data type |
Cblaze::HasSIMDSub< T1, T2, typename > | Availability of a SIMD subtraction for the given data types |
Cblaze::HasSIMDTan< T > | Availability of a SIMD tangent operation for the given data type |
Cblaze::HasSIMDTanh< T > | Availability of a SIMD hyperbolic tangent operation for the given data type |
Cblaze::HasSIMDTrunc< T > | Availability of a SIMD trunc operation for the given data type |
Cblaze::HasSize< T, S > | Compile time size check |
Cblaze::HaveSameSize< T1, T2 > | Compile time size check |
Cblaze::IsAdaptor< T > | Compile time check for adaptors |
Cblaze::IsAligned< T > | Compile time check for the alignment of data types |
Cblaze::IsArithmetic< T > | Compile time check for arithmetic data types |
Cblaze::IsArray< T > | Compile time type check |
Cblaze::IsAssignable< T, U > | Compile time type check |
Cblaze::IsBLASCompatible< T > | Compile time check for data types |
Cblaze::IsBand< T > | Compile time check for bands |
Cblaze::IsBaseOf< Base, Derived > | Compile time analysis of an inheritance relationship |
Cblaze::IsBoolean< T > | Compile time check for boolean types |
Cblaze::IsBuiltin< T > | Compile time check for built-in data types |
Cblaze::IsCharacter< T > | Compile time check for character types |
Cblaze::IsClass< T > | Compile time type check |
Cblaze::IsColumn< T > | Compile time check for columns |
Cblaze::IsColumns< T > | Compile time check for column selections |
Cblaze::IsCommutative< T1, T2, typename > | Compile time check for the commutativity of data types |
Cblaze::IsComplex< T > | Compile time check for complex types |
Cblaze::IsComplexDouble< T > | Compile time check for single precision complex types |
Cblaze::IsComplexFloat< T > | Compile time check for single precision complex types |
Cblaze::IsComputation< T > | Compile time check whether the given type is a computational expression template |
Cblaze::IsConst< T > | Compile time check for constant data types |
Cblaze::IsConstructible< T, Args > | Compile time type check |
Cblaze::IsContiguous< T > | Compile time check for the memory layout of data types |
Cblaze::IsConvertible< From, To > | Compile time pointer relationship constraint |
Cblaze::IsCopyAssignable< T > | Compile time type check |
Cblaze::IsCopyConstructible< T > | Compile time type check |
Cblaze::IsCustom< T > | Compile time check for custom data types |
Cblaze::IsDefaultConstructible< T > | Compile time type check |
Cblaze::IsDestructible< T > | Compile time type check |
Cblaze::IsDiagonal< T > | Compile time check for diagonal matrices |
Cblaze::IsDouble< T > | Compile time check for double precision floating point types |
Cblaze::IsElements< T > | Compile time check for element selections |
Cblaze::IsEmpty< T > | Compile time type check |
Cblaze::IsEnum< T > | Compile time check for complete enumeration types |
Cblaze::IsEven< N > | Compile time check whether a compile time constant expression is even |
Cblaze::IsFloat< T > | Compile time check for single precision floating point types |
Cblaze::IsFloatingPoint< T > | Compile time check for floating point data types |
Cblaze::IsGeneral< T > | Compile time check for general matrices |
Cblaze::IsIdentity< T > | Compile time check for identity matrices |
Cblaze::IsInitializer< T > | Compile time check for custom data types |
Cblaze::IsInteger< T > | Compile time check for integer types |
Cblaze::IsIntegral< T > | Compile time check for integral data types |
Cblaze::IsInvertible< T > | Compile time check for data types |
Cblaze::IsLValueReference< T > | Compile time type check |
Cblaze::IsLong< T > | Compile time check for long integer types |
Cblaze::IsLongDouble< T > | Compile time check for extended precision floating point types |
Cblaze::IsMoveAssignable< T > | Compile time type check |
Cblaze::IsMoveConstructible< T > | Compile time type check |
Cblaze::IsMultipleOf< M, N > | Compile time check for a multiplicative relationship of two integral values |
Cblaze::IsNothrowAssignable< T, U > | Compile time type check |
Cblaze::IsNothrowConstructible< T, Args > | Compile time type check |
Cblaze::IsNothrowCopyAssignable< T > | Compile time type check |
Cblaze::IsNothrowCopyConstructible< T > | Compile time type check |
Cblaze::IsNothrowDefaultConstructible< T > | Compile time type check |
Cblaze::IsNothrowDestructible< T > | Compile time type check |
Cblaze::IsNothrowMoveAssignable< T > | Compile time type check |
Cblaze::IsNothrowMoveConstructible< T > | Compile time type check |
Cblaze::IsNumeric< T > | Compile time check for numeric types |
Cblaze::IsObject< T > | Compile time type check |
Cblaze::IsOdd< N > | Compile time check whether a compile time constant expression is odd |
Cblaze::IsOperation< T > | Compile time check whether the given type is an operational expression template |
Cblaze::IsOpposedView< T > | Compile time check for resizable data types |
Cblaze::IsPadded< T > | Compile time check for data types with padding |
Cblaze::IsPaddingEnabled< T > | Compile time check for data types |
Cblaze::IsPod< T > | Compile time check for pod data types |
Cblaze::IsPointer< T > | Compile time type check |
Cblaze::IsPowerOf< B, N > | Compile time check for a power relationship of integral values to a given base |
Cblaze::IsRValueReference< T > | Compile time type check |
Cblaze::IsReference< T > | Compile time type check |
Cblaze::IsResizable< T > | Compile time check for resizable data types |
Cblaze::IsRestricted< T > | Compile time check for data types with restricted data access |
Cblaze::IsRow< T > | Compile time check for rows |
Cblaze::IsRows< T > | Compile time check for row selections |
Cblaze::IsSIMDCombinable< T1, T2, Ts > | Compile time check for data types |
Cblaze::IsSIMDEnabled< T, Args > | Compile time check for data types |
Cblaze::IsSMPAssignable< T > | Compile time check for data types |
Cblaze::IsSame< A, B > | Type relationship analysis |
Cblaze::IsScalar< T > | Compile time check for scalar types |
Cblaze::IsShort< T > | Compile time check for short integer types |
Cblaze::IsSigned< T > | Compile time check for signed data types |
Cblaze::IsSparseElement< T > | Compile time check whether the given type is a sparse element type |
Cblaze::IsSquare< T > | Compile time check for square matrices |
Cblaze::IsStatic< T > | Compile time check for static data types |
Cblaze::IsStrictlySame< A, B > | Compile time type relationship analysis |
Cblaze::IsStrictlyTriangular< T > | Compile time check for strictly triangular matrix types |
Cblaze::IsSubmatrix< T > | Compile time check for submatrices |
Cblaze::IsSubvector< T > | Compile time check for subvectors |
Cblaze::IsTemporary< T > | Compile time check whether the given type is a temporary vector or matrix type |
Cblaze::IsTransformation< T > | Compile time check whether the given type is a transformation expression template |
Cblaze::IsTriangular< T > | Compile time check for triangular matrix types |
Cblaze::IsUniTriangular< T > | Compile time check for unitriangular matrix types |
Cblaze::IsUnion< T > | Compile time check for union data types |
Cblaze::IsUnsigned< T > | Compile time check for unsigned data types |
Cblaze::IsValid< T > | Compile time type check |
Cblaze::IsVectorizable< T > | Compile time check for vectorizable types |
Cblaze::IsVoid< T > | Compile time check for the void data type |
Cblaze::IsVolatile< T > | Compile time check for volatile data types |
Cblaze::RequiresEvaluation< T > | Compile time check to query the requirement to evaluate an expression |
Cblaze::StorageOrder< T > | Evaluation of the storage order of a given matrix type |
Cblaze::TransposeFlag< T > | Evaluation of the transpose flag of a given matrix type |
Cblaze::YieldsDiagonal< OP, MT, MTs > | Compile time check for operations on matrices |
Cblaze::YieldsHermitian< OP, MT, MTs > | Compile time check for operations on matrices |
Cblaze::YieldsIdentity< OP, MT, MTs > | Compile time check for operations on matrices |
Cblaze::YieldsLower< OP, MT, MTs > | Compile time check for operations on matrices |
Cblaze::YieldsStrictlyLower< OP, MT, MTs > | Compile time check for operations on matrices |
Cblaze::YieldsStrictlyTriangular< OP, MT, MTs > | Compile time check for operations on matrices |
Cblaze::YieldsStrictlyUpper< OP, MT, MTs > | Compile time check for operations on matrices |
Cblaze::YieldsSymmetric< OP, MT, MTs > | Compile time check for operations on matrices |
Cblaze::YieldsTriangular< OP, MT, MTs > | Compile time check for operations on matrices |
Cblaze::YieldsUniLower< OP, MT, MTs > | Compile time check for operations on matrices |
Cblaze::YieldsUniTriangular< OP, MT, MTs > | Compile time check for operations on matrices |
Cblaze::YieldsUniUpper< OP, MT, MTs > | Compile time check for operations on matrices |
Cblaze::YieldsUniform< OP, T, Ts > | Compile time check for operations on vectors and matrices |
Cblaze::YieldsUpper< OP, MT, MTs > | Compile time check for operations on matrices |
Cblaze::YieldsZero< OP, T, Ts > | Compile time check for operations on vectors and matrices |
Cblaze::Inv | Generic wrapper for the inv() function |
Cblaze::InvAdd | Generic wrapper for the inverted addition operator |
Cblaze::InvCbrt | Generic wrapper for the invcbrt() function |
Cblaze::InvSqrt | Generic wrapper for the invsqrt() function |
►CIsCUDAAssignableHelper | |
Cblaze::IsCUDAAssignable< T > | Compile time check for data types |
►CIsDetected | |
Cblaze::IsClearable< T > | Compile time check for clearable data types |
Cblaze::IsShrinkable< T > | Compile time check for shrinkable data types |
►CIsHermitianHelper | |
Cblaze::IsHermitian< T > | Compile time check for Hermitian matrices |
►CIsLowerHelper | |
Cblaze::IsLower< T > | Compile time check for lower triangular matrices |
►CIsStrictlyLowerHelper | |
Cblaze::IsStrictlyLower< T > | Compile time check for strictly lower triangular matrices |
►CIsStrictlyUpperHelper | |
Cblaze::IsStrictlyUpper< T > | Compile time check for strictly upper triangular matrices |
►CIsSymmetricHelper | |
Cblaze::IsSymmetric< T > | Compile time check for symmetric matrices |
►CIsUniformHelper | |
Cblaze::IsUniform< T > | Compile time check for uniform vectors and matrices |
►CIsUniLowerHelper | |
Cblaze::IsUniLower< T > | Compile time check for lower unitriangular matrices |
►CIsUniUpperHelper | |
Cblaze::IsUniUpper< T > | Compile time check for upper unitriangular matrices |
►CIsUpperHelper | |
Cblaze::IsUpper< T > | Compile time check for upper triangular matrices |
►CIsZeroHelper | |
Cblaze::IsZero< T > | Compile time check for zero vectors or matrices |
Cblaze::Join< OP > | Generic wrapper for unpacking paired function arguments |
Cblaze::Kron | Generic wrapper for the Kronecker product |
Cblaze::L1Norm | Generic wrapper for the l1Norm() function |
Cblaze::L2Norm | Generic wrapper for the l2Norm() function |
Cblaze::L3Norm | Generic wrapper for the l3Norm() function |
Cblaze::L4Norm | Generic wrapper for the l4Norm() function |
Cblaze::LeftShiftAssign | Generic wrapper for bitwise left-shift assignment |
Cblaze::Length< TL > | Calculating the length of a type list |
Cblaze::Less | Generic wrapper for the less-than relational operator |
Cblaze::LGamma | Generic wrapper for the lgamma() function |
Cblaze::Limits< Type > | Numerical limits of built-in data types |
Cblaze::Log | Generic wrapper for the log() function |
Cblaze::Log10 | Generic wrapper for the log10() function |
Cblaze::Log1p | Generic wrapper for the log1p() function |
Cblaze::Log2 | Generic wrapper for the log2() function |
Cblaze::LowerMatrix< MT, SO, DF > | Matrix adapter for lower triangular matrices |
Cblaze::LowType< T1, T2, typename > | Base template for the LowType type trait |
Cblaze::LpNorm< P > | Generic wrapper for the lpNorm() function |
Cblaze::MAC | Generic wrapper for the multiply-accumulate ( ; MAC) operation |
Cmake_index_sequence | Import of the std::make_index_sequence alias template into the Blaze namespace |
Cmake_integer_sequence | Import of the std::make_integer_sequence alias template into the Blaze namespace |
Cblaze::MakeComplex< T > | Converting the given type to the matching 'complex' type |
Cblaze::MakePair | Generic wrapper for the make_pair() function |
Cblaze::MakeSigned< T > | Compile time type conversion into a signed integral type |
Cblaze::MakeUnsigned< T > | Compile time type conversion into an unsigned integral type |
►Cblaze::Matrix< MT, SO > | Base class for matrices |
Cblaze::DenseMatrix< MT, SO > | Base class for dense matrices |
Cblaze::SparseMatrix< MT, SO > | Base class for sparse matrices |
►Cblaze::Matrix< CompressedMatrix< Type, SO, Tag >, SO > | |
►Cblaze::SparseMatrix< CompressedMatrix< Type, SO, Tag >, SO > | |
Cblaze::CompressedMatrix< Type, SO, Tag > | Efficient implementation of a compressed matrix |
►Cblaze::Matrix< CustomMatrix< Type, AF, PF, SO, Tag, RT >, SO > | |
►Cblaze::DenseMatrix< CustomMatrix< Type, AF, PF, SO, Tag, RT >, SO > | |
Cblaze::CustomMatrix< Type, AF, PF, SO, Tag, RT > | Efficient implementation of a customizable matrix |
►Cblaze::Matrix< DMatDeclDiagExpr< MT, SO >, SO > | |
►Cblaze::DenseMatrix< DMatDeclDiagExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDeclDiagExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< DenseMatrix< DMatDeclDiagExpr< MT, SO >, SO > > | |
►Cblaze::DeclDiagExpr< DenseMatrix< DMatDeclDiagExpr< MT, SO >, SO > > | |
Cblaze::DMatDeclDiagExpr< MT, SO > | Expression object for the explicit diagonal declaration of dense matrices |
►Cblaze::Matrix< DMatDeclHermExpr< MT, SO >, SO > | |
►Cblaze::DenseMatrix< DMatDeclHermExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDeclHermExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< DenseMatrix< DMatDeclHermExpr< MT, SO >, SO > > | |
►Cblaze::DeclHermExpr< DenseMatrix< DMatDeclHermExpr< MT, SO >, SO > > | |
Cblaze::DMatDeclHermExpr< MT, SO > | Expression object for the explicit Hermitian declaration of dense matrices |
►Cblaze::Matrix< DMatDeclLowExpr< MT, SO >, SO > | |
►Cblaze::DenseMatrix< DMatDeclLowExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDeclLowExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< DenseMatrix< DMatDeclLowExpr< MT, SO >, SO > > | |
►Cblaze::DeclLowExpr< DenseMatrix< DMatDeclLowExpr< MT, SO >, SO > > | |
Cblaze::DMatDeclLowExpr< MT, SO > | Expression object for the explicit lower declaration of dense matrices |
►Cblaze::Matrix< DMatDeclStrLowExpr< MT, SO >, SO > | |
►Cblaze::DenseMatrix< DMatDeclStrLowExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDeclStrLowExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< DenseMatrix< DMatDeclStrLowExpr< MT, SO >, SO > > | |
►Cblaze::DeclStrLowExpr< DenseMatrix< DMatDeclStrLowExpr< MT, SO >, SO > > | |
Cblaze::DMatDeclStrLowExpr< MT, SO > | Expression object for the explicit strictly lower declaration of dense matrices |
►Cblaze::Matrix< DMatDeclStrUppExpr< MT, SO >, SO > | |
►Cblaze::DenseMatrix< DMatDeclStrUppExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDeclStrUppExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< DenseMatrix< DMatDeclStrUppExpr< MT, SO >, SO > > | |
►Cblaze::DeclStrUppExpr< DenseMatrix< DMatDeclStrUppExpr< MT, SO >, SO > > | |
Cblaze::DMatDeclStrUppExpr< MT, SO > | Expression object for the explicit strictly upper declaration of dense matrices |
►Cblaze::Matrix< DMatDeclSymExpr< MT, SO >, SO > | |
►Cblaze::DenseMatrix< DMatDeclSymExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDeclSymExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< DenseMatrix< DMatDeclSymExpr< MT, SO >, SO > > | |
►Cblaze::DeclSymExpr< DenseMatrix< DMatDeclSymExpr< MT, SO >, SO > > | |
Cblaze::DMatDeclSymExpr< MT, SO > | Expression object for the explicit symmetry declaration of dense matrices |
►Cblaze::Matrix< DMatDeclUniLowExpr< MT, SO >, SO > | |
►Cblaze::DenseMatrix< DMatDeclUniLowExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDeclUniLowExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< DenseMatrix< DMatDeclUniLowExpr< MT, SO >, SO > > | |
►Cblaze::DeclUniLowExpr< DenseMatrix< DMatDeclUniLowExpr< MT, SO >, SO > > | |
Cblaze::DMatDeclUniLowExpr< MT, SO > | Expression object for the explicit unilower declaration of dense matrices |
►Cblaze::Matrix< DMatDeclUniUppExpr< MT, SO >, SO > | |
►Cblaze::DenseMatrix< DMatDeclUniUppExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDeclUniUppExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< DenseMatrix< DMatDeclUniUppExpr< MT, SO >, SO > > | |
►Cblaze::DeclUniUppExpr< DenseMatrix< DMatDeclUniUppExpr< MT, SO >, SO > > | |
Cblaze::DMatDeclUniUppExpr< MT, SO > | Expression object for the explicit uniupper declaration of dense matrices |
►Cblaze::Matrix< DMatDeclUppExpr< MT, SO >, SO > | |
►Cblaze::DenseMatrix< DMatDeclUppExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDeclUppExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< DenseMatrix< DMatDeclUppExpr< MT, SO >, SO > > | |
►Cblaze::DeclUppExpr< DenseMatrix< DMatDeclUppExpr< MT, SO >, SO > > | |
Cblaze::DMatDeclUppExpr< MT, SO > | Expression object for the explicit upper declaration of dense matrices |
►Cblaze::Matrix< DMatDMatAddExpr< MT1, MT2, SO >, SO > | |
►Cblaze::DenseMatrix< DMatDMatAddExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDMatAddExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::AddExpr< DenseMatrix< DMatDMatAddExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::MatMatAddExpr< DenseMatrix< DMatDMatAddExpr< MT1, MT2, SO >, SO > > | |
Cblaze::DMatDMatAddExpr< MT1, MT2, SO > | Expression object for dense matrix-dense matrix additions |
►Cblaze::Matrix< DMatDMatKronExpr< MT1, MT2, SO >, SO > | |
►Cblaze::DenseMatrix< DMatDMatKronExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDMatKronExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::KronExpr< DenseMatrix< DMatDMatKronExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::MatMatKronExpr< DenseMatrix< DMatDMatKronExpr< MT1, MT2, SO >, SO > > | |
Cblaze::DMatDMatKronExpr< MT1, MT2, SO > | Expression object for dense matrix-dense matrix Kronecker products |
►Cblaze::Matrix< DMatDMatMapExpr< MT1, MT2, OP, SO >, SO > | |
►Cblaze::DenseMatrix< DMatDMatMapExpr< MT1, MT2, OP, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDMatMapExpr< MT1, MT2, OP, SO >, SO > > | |
►Cblaze::BinaryMapExpr< DenseMatrix< DMatDMatMapExpr< MT1, MT2, OP, SO >, SO > > | |
►Cblaze::MatMatMapExpr< DenseMatrix< DMatDMatMapExpr< MT1, MT2, OP, SO >, SO > > | |
Cblaze::DMatDMatMapExpr< MT1, MT2, OP, SO > | Expression object for the dense matrix-dense matrix map() function |
►Cblaze::Matrix< DMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, SO > | |
►Cblaze::DenseMatrix< DMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > | |
►Cblaze::Expression< DenseMatrix< DMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MultExpr< DenseMatrix< DMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< DMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
Cblaze::DMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for dense matrix-dense matrix multiplications |
►Cblaze::Matrix< DMatDMatSchurExpr< MT1, MT2, SO >, SO > | |
►Cblaze::DenseMatrix< DMatDMatSchurExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDMatSchurExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::SchurExpr< DenseMatrix< DMatDMatSchurExpr< MT1, MT2, SO >, SO > > | |
Cblaze::DMatDMatSchurExpr< MT1, MT2, SO > | Expression object for dense matrix-dense matrix Schur products |
►Cblaze::Matrix< DMatDMatSolveExpr< MT1, MT2, SO >, SO > | |
►Cblaze::DenseMatrix< DMatDMatSolveExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDMatSolveExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::SolveExpr< DenseMatrix< DMatDMatSolveExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::MatMatSolveExpr< DenseMatrix< DMatDMatSolveExpr< MT1, MT2, SO >, SO > > | |
Cblaze::DMatDMatSolveExpr< MT1, MT2, SO > | Expression object for dense matrix-dense matrix solvers |
►Cblaze::Matrix< DMatDMatSubExpr< MT1, MT2, SO >, SO > | |
►Cblaze::DenseMatrix< DMatDMatSubExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDMatSubExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::SubExpr< DenseMatrix< DMatDMatSubExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::MatMatSubExpr< DenseMatrix< DMatDMatSubExpr< MT1, MT2, SO >, SO > > | |
Cblaze::DMatDMatSubExpr< MT1, MT2, SO > | Expression object for dense matrix-dense matrix subtractions |
►Cblaze::Matrix< DMatEvalExpr< MT, SO >, SO > | |
►Cblaze::DenseMatrix< DMatEvalExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatEvalExpr< MT, SO >, SO > > | |
►Cblaze::EvalExpr< DenseMatrix< DMatEvalExpr< MT, SO >, SO > > | |
►Cblaze::MatEvalExpr< DenseMatrix< DMatEvalExpr< MT, SO >, SO > > | |
Cblaze::DMatEvalExpr< MT, SO > | Expression object for the forced evaluation of dense matrices |
►Cblaze::Matrix< DMatExpExpr< MT, SO >, SO > | |
►Cblaze::DenseMatrix< DMatExpExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatExpExpr< MT, SO >, SO > > | |
►Cblaze::MatExpExpr< DenseMatrix< DMatExpExpr< MT, SO >, SO > > | |
Cblaze::DMatExpExpr< MT, SO > | Expression object for dense matrix exponential |
►Cblaze::Matrix< DMatGenExpr< MT, OP, SO >, SO > | |
►Cblaze::DenseMatrix< DMatGenExpr< MT, OP, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatGenExpr< MT, OP, SO >, SO > > | |
►Cblaze::GenExpr< DenseMatrix< DMatGenExpr< MT, OP, SO >, SO > > | |
►Cblaze::MatGenExpr< DenseMatrix< DMatGenExpr< MT, OP, SO >, SO > > | |
Cblaze::DMatGenExpr< MT, OP, SO > | Expression object for the dense matrix generate() function |
►Cblaze::Matrix< DMatInvExpr< MT, SO >, SO > | |
►Cblaze::DenseMatrix< DMatInvExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatInvExpr< MT, SO >, SO > > | |
►Cblaze::MatInvExpr< DenseMatrix< DMatInvExpr< MT, SO >, SO > > | |
Cblaze::DMatInvExpr< MT, SO > | Expression object for dense matrix inversions |
►Cblaze::Matrix< DMatMapExpr< MT, OP, SO >, SO > | |
►Cblaze::DenseMatrix< DMatMapExpr< MT, OP, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatMapExpr< MT, OP, SO >, SO > > | |
►Cblaze::UnaryMapExpr< DenseMatrix< DMatMapExpr< MT, OP, SO >, SO > > | |
►Cblaze::MatMapExpr< DenseMatrix< DMatMapExpr< MT, OP, SO >, SO > > | |
Cblaze::DMatMapExpr< MT, OP, SO > | Expression object for the dense matrix map() function |
►Cblaze::Matrix< DMatNoAliasExpr< MT, SO >, SO > | |
►Cblaze::DenseMatrix< DMatNoAliasExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatNoAliasExpr< MT, SO >, SO > > | |
►Cblaze::NoAliasExpr< DenseMatrix< DMatNoAliasExpr< MT, SO >, SO > > | |
►Cblaze::MatNoAliasExpr< DenseMatrix< DMatNoAliasExpr< MT, SO >, SO > > | |
Cblaze::DMatNoAliasExpr< MT, SO > | Expression object for the non-aliased evaluation of dense matrices |
►Cblaze::Matrix< DMatNoSIMDExpr< MT, SO >, SO > | |
►Cblaze::DenseMatrix< DMatNoSIMDExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatNoSIMDExpr< MT, SO >, SO > > | |
►Cblaze::NoSIMDExpr< DenseMatrix< DMatNoSIMDExpr< MT, SO >, SO > > | |
►Cblaze::MatNoSIMDExpr< DenseMatrix< DMatNoSIMDExpr< MT, SO >, SO > > | |
Cblaze::DMatNoSIMDExpr< MT, SO > | Expression object for the non-SIMD evaluation of dense matrices |
►Cblaze::Matrix< DMatRepeatExpr< MT, SO, CRAs... >, SO > | |
►Cblaze::DenseMatrix< DMatRepeatExpr< MT, SO, CRAs... >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatRepeatExpr< MT, SO, CRAs... >, SO > > | |
►Cblaze::RepeatExpr< DenseMatrix< DMatRepeatExpr< MT, SO, CRAs... >, SO > > | |
►Cblaze::MatRepeatExpr< DenseMatrix< DMatRepeatExpr< MT, SO, CRAs... >, SO >, CRAs... > | |
Cblaze::DMatRepeatExpr< MT, SO, CRAs > | Expression object for the dense matrix repeat() function |
►Cblaze::Matrix< DMatScalarDivExpr< MT, ST, SO >, SO > | |
►Cblaze::DenseMatrix< DMatScalarDivExpr< MT, ST, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatScalarDivExpr< MT, ST, SO >, SO > > | |
►Cblaze::DivExpr< DenseMatrix< DMatScalarDivExpr< MT, ST, SO >, SO > > | |
►Cblaze::MatScalarDivExpr< DenseMatrix< DMatScalarDivExpr< MT, ST, SO >, SO > > | |
Cblaze::DMatScalarDivExpr< MT, ST, SO > | Expression object for divisions of a dense matrix by a scalar |
►Cblaze::Matrix< DMatScalarMultExpr< MT, ST, SO >, SO > | |
►Cblaze::DenseMatrix< DMatScalarMultExpr< MT, ST, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatScalarMultExpr< MT, ST, SO >, SO > > | |
►Cblaze::MultExpr< DenseMatrix< DMatScalarMultExpr< MT, ST, SO >, SO > > | |
►Cblaze::MatScalarMultExpr< DenseMatrix< DMatScalarMultExpr< MT, ST, SO >, SO > > | |
Cblaze::DMatScalarMultExpr< MT, ST, SO > | Expression object for dense matrix-scalar multiplications |
►Cblaze::Matrix< DMatSerialExpr< MT, SO >, SO > | |
►Cblaze::DenseMatrix< DMatSerialExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatSerialExpr< MT, SO >, SO > > | |
►Cblaze::SerialExpr< DenseMatrix< DMatSerialExpr< MT, SO >, SO > > | |
►Cblaze::MatSerialExpr< DenseMatrix< DMatSerialExpr< MT, SO >, SO > > | |
Cblaze::DMatSerialExpr< MT, SO > | Expression object for the forced serial evaluation of dense matrices |
►Cblaze::Matrix< DMatSMatAddExpr< MT1, MT2, SO >, SO > | |
►Cblaze::DenseMatrix< DMatSMatAddExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatSMatAddExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::AddExpr< DenseMatrix< DMatSMatAddExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::MatMatAddExpr< DenseMatrix< DMatSMatAddExpr< MT1, MT2, SO >, SO > > | |
Cblaze::DMatSMatAddExpr< MT1, MT2, SO > | Expression object for dense matrix-sparse matrix additions |
►Cblaze::Matrix< DMatSMatKronExpr< MT1, MT2, SO >, SO > | |
►Cblaze::SparseMatrix< DMatSMatKronExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< DMatSMatKronExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::KronExpr< SparseMatrix< DMatSMatKronExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::MatMatKronExpr< SparseMatrix< DMatSMatKronExpr< MT1, MT2, SO >, SO > > | |
Cblaze::DMatSMatKronExpr< MT1, MT2, SO > | Expression object for dense matrix-sparse matrix Kronecker product |
►Cblaze::Matrix< DMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, SO > | |
►Cblaze::DenseMatrix< DMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > | |
►Cblaze::Expression< DenseMatrix< DMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MultExpr< DenseMatrix< DMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< DMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
Cblaze::DMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for dense matrix-sparse matrix multiplications |
►Cblaze::Matrix< DMatSMatSubExpr< MT1, MT2, SO >, SO > | |
►Cblaze::DenseMatrix< DMatSMatSubExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatSMatSubExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::SubExpr< DenseMatrix< DMatSMatSubExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::MatMatSubExpr< DenseMatrix< DMatSMatSubExpr< MT1, MT2, SO >, SO > > | |
Cblaze::DMatSMatSubExpr< MT1, MT2, SO > | Expression object for dense matrix-sparse matrix subtractions |
►Cblaze::Matrix< DMatTDMatAddExpr< MT1, MT2 >, SO > | |
►Cblaze::DenseMatrix< DMatTDMatAddExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< DenseMatrix< DMatTDMatAddExpr< MT1, MT2 >, false > > | |
►Cblaze::AddExpr< DenseMatrix< DMatTDMatAddExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatAddExpr< DenseMatrix< DMatTDMatAddExpr< MT1, MT2 >, false > > | |
Cblaze::DMatTDMatAddExpr< MT1, MT2 > | Expression object for dense matrix-transpose dense matrix additions |
►Cblaze::Matrix< DMatTDMatMapExpr< MT1, MT2, OP >, SO > | |
►Cblaze::DenseMatrix< DMatTDMatMapExpr< MT1, MT2, OP >, false > | |
►Cblaze::Expression< DenseMatrix< DMatTDMatMapExpr< MT1, MT2, OP >, false > > | |
►Cblaze::BinaryMapExpr< DenseMatrix< DMatTDMatMapExpr< MT1, MT2, OP >, false > > | |
►Cblaze::MatMatMapExpr< DenseMatrix< DMatTDMatMapExpr< MT1, MT2, OP >, false > > | |
Cblaze::DMatTDMatMapExpr< MT1, MT2, OP > | Expression object for the dense matrix/tranpose dense matrix map() function |
►Cblaze::Matrix< DMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, SO > | |
►Cblaze::DenseMatrix< DMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > | |
►Cblaze::Expression< DenseMatrix< DMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MultExpr< DenseMatrix< DMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< DMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
Cblaze::DMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for dense matrix-transpose dense matrix multiplications |
►Cblaze::Matrix< DMatTDMatSchurExpr< MT1, MT2 >, SO > | |
►Cblaze::DenseMatrix< DMatTDMatSchurExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< DenseMatrix< DMatTDMatSchurExpr< MT1, MT2 >, false > > | |
►Cblaze::SchurExpr< DenseMatrix< DMatTDMatSchurExpr< MT1, MT2 >, false > > | |
Cblaze::DMatTDMatSchurExpr< MT1, MT2 > | Expression object for dense matrix-transpose dense matrix Schur product |
►Cblaze::Matrix< DMatTDMatSubExpr< MT1, MT2 >, SO > | |
►Cblaze::DenseMatrix< DMatTDMatSubExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< DenseMatrix< DMatTDMatSubExpr< MT1, MT2 >, false > > | |
►Cblaze::SubExpr< DenseMatrix< DMatTDMatSubExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatSubExpr< DenseMatrix< DMatTDMatSubExpr< MT1, MT2 >, false > > | |
Cblaze::DMatTDMatSubExpr< MT1, MT2 > | Expression object for dense matrix-transpose dense matrix subtractions |
►Cblaze::Matrix< DMatTransExpr< MT, SO >, SO > | |
►Cblaze::DenseMatrix< DMatTransExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatTransExpr< MT, SO >, SO > > | |
►Cblaze::TransExpr< DenseMatrix< DMatTransExpr< MT, SO >, SO > > | |
►Cblaze::MatTransExpr< DenseMatrix< DMatTransExpr< MT, SO >, SO > > | |
Cblaze::DMatTransExpr< MT, SO > | Expression object for dense matrix transpositions |
►Cblaze::Matrix< DMatTransposer< MT, SO >, SO > | |
►Cblaze::DenseMatrix< DMatTransposer< MT, SO >, SO > | |
Cblaze::DMatTransposer< MT, SO > | Expression object for the transposition of a dense matrix |
►Cblaze::Matrix< DMatTSMatAddExpr< MT1, MT2 >, SO > | |
►Cblaze::DenseMatrix< DMatTSMatAddExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< DenseMatrix< DMatTSMatAddExpr< MT1, MT2 >, false > > | |
►Cblaze::AddExpr< DenseMatrix< DMatTSMatAddExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatAddExpr< DenseMatrix< DMatTSMatAddExpr< MT1, MT2 >, false > > | |
Cblaze::DMatTSMatAddExpr< MT1, MT2 > | Expression object for dense matrix-sparse matrix additions |
►Cblaze::Matrix< DMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, SO > | |
►Cblaze::DenseMatrix< DMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > | |
►Cblaze::Expression< DenseMatrix< DMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MultExpr< DenseMatrix< DMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< DMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
Cblaze::DMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for dense matrix-transpose sparse matrix multiplications |
►Cblaze::Matrix< DMatTSMatSubExpr< MT1, MT2 >, SO > | |
►Cblaze::DenseMatrix< DMatTSMatSubExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< DenseMatrix< DMatTSMatSubExpr< MT1, MT2 >, false > > | |
►Cblaze::SubExpr< DenseMatrix< DMatTSMatSubExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatSubExpr< DenseMatrix< DMatTSMatSubExpr< MT1, MT2 >, false > > | |
Cblaze::DMatTSMatSubExpr< MT1, MT2 > | Expression object for dense matrix-transpose sparse matrix subtractions |
►Cblaze::Matrix< DVecDVecOuterExpr< VT1, VT2, OP >, SO > | |
►Cblaze::DenseMatrix< DVecDVecOuterExpr< VT1, VT2, OP >, false > | |
►Cblaze::Expression< DenseMatrix< DVecDVecOuterExpr< VT1, VT2, OP >, false > > | |
►Cblaze::BinaryMapExpr< DenseMatrix< DVecDVecOuterExpr< VT1, VT2, OP >, false > > | |
►Cblaze::VecTVecMapExpr< DenseMatrix< DVecDVecOuterExpr< VT1, VT2, OP >, false > > | |
Cblaze::DVecDVecOuterExpr< VT1, VT2, OP > | Expression object for the dense vector-dense vector outer map() function |
►Cblaze::Matrix< DVecExpandExpr< VT, TF, CEAs... >, SO > | |
►Cblaze::DenseMatrix< DVecExpandExpr< VT, TF, CEAs... >, !TF > | |
►Cblaze::Expression< DenseMatrix< DVecExpandExpr< VT, TF, CEAs... >, !TF > > | |
►Cblaze::ExpandExpr< DenseMatrix< DVecExpandExpr< VT, TF, CEAs... >, !TF > > | |
►Cblaze::VecExpandExpr< DenseMatrix< DVecExpandExpr< VT, TF, CEAs... >, !TF >, CEAs... > | |
Cblaze::DVecExpandExpr< VT, TF, CEAs > | Expression object for dense vector expansion |
►Cblaze::Matrix< DVecSVecOuterExpr< VT1, VT2 >, SO > | |
►Cblaze::SparseMatrix< DVecSVecOuterExpr< VT1, VT2 >, false > | |
►Cblaze::Expression< SparseMatrix< DVecSVecOuterExpr< VT1, VT2 >, false > > | |
►Cblaze::MultExpr< SparseMatrix< DVecSVecOuterExpr< VT1, VT2 >, false > > | |
►Cblaze::VecTVecMultExpr< SparseMatrix< DVecSVecOuterExpr< VT1, VT2 >, false > > | |
Cblaze::DVecSVecOuterExpr< VT1, VT2 > | Expression object for dense vector-sparse vector outer products |
►Cblaze::Matrix< DynamicMatrix< Type, SO, Alloc, Tag >, SO > | |
►Cblaze::DenseMatrix< DynamicMatrix< Type, SO, Alloc, Tag >, SO > | |
Cblaze::DynamicMatrix< Type, SO, Alloc, Tag > | Efficient implementation of a dynamic matrix |
►Cblaze::Matrix< HybridMatrix< Type, M, N, SO, AF, PF, Tag >, SO > | |
►Cblaze::DenseMatrix< HybridMatrix< Type, M, N, SO, AF, PF, Tag >, SO > | |
Cblaze::HybridMatrix< Type, M, N, SO, AF, PF, Tag > | Efficient implementation of a dynamically sized matrix with static memory |
►Cblaze::Matrix< IdentityMatrix< Type, SO, Tag >, SO > | |
►Cblaze::SparseMatrix< IdentityMatrix< Type, SO, Tag >, SO > | |
►Cblaze::Expression< SparseMatrix< IdentityMatrix< Type, SO, Tag >, SO > > | |
Cblaze::IdentityMatrix< Type, SO, Tag > | Efficient implementation of an identity matrix |
►Cblaze::Matrix< InitializerMatrix< Type, Tag >, SO > | |
►Cblaze::DenseMatrix< InitializerMatrix< Type, Tag >, false > | |
Cblaze::InitializerMatrix< Type, Tag > | Dense matrix representation of an initializer list |
►Cblaze::Matrix< PT, SO > | |
►Cblaze::DenseMatrix< PT, IsColumnMajorMatrix_v< MT > > | |
Cblaze::DenseMatrixProxy< PT, MT > | Proxy backend for dense matrix types |
►Cblaze::SparseMatrix< PT, IsColumnMajorMatrix_v< MT > > | |
Cblaze::SparseMatrixProxy< PT, MT > | Proxy backend for sparse matrix types |
►Cblaze::Matrix< SMatDeclDiagExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatDeclDiagExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatDeclDiagExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< SparseMatrix< SMatDeclDiagExpr< MT, SO >, SO > > | |
►Cblaze::DeclDiagExpr< SparseMatrix< SMatDeclDiagExpr< MT, SO >, SO > > | |
Cblaze::SMatDeclDiagExpr< MT, SO > | Expression object for the explicit diagonal declaration of sparse matrices |
►Cblaze::Matrix< SMatDeclHermExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatDeclHermExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatDeclHermExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< SparseMatrix< SMatDeclHermExpr< MT, SO >, SO > > | |
►Cblaze::DeclHermExpr< SparseMatrix< SMatDeclHermExpr< MT, SO >, SO > > | |
Cblaze::SMatDeclHermExpr< MT, SO > | Expression object for the explicit Hermitian declaration of sparse matrices |
►Cblaze::Matrix< SMatDeclLowExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatDeclLowExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatDeclLowExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< SparseMatrix< SMatDeclLowExpr< MT, SO >, SO > > | |
►Cblaze::DeclLowExpr< SparseMatrix< SMatDeclLowExpr< MT, SO >, SO > > | |
Cblaze::SMatDeclLowExpr< MT, SO > | Expression object for the explicit lower declaration of sparse matrices |
►Cblaze::Matrix< SMatDeclStrLowExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatDeclStrLowExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatDeclStrLowExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< SparseMatrix< SMatDeclStrLowExpr< MT, SO >, SO > > | |
►Cblaze::DeclStrLowExpr< SparseMatrix< SMatDeclStrLowExpr< MT, SO >, SO > > | |
Cblaze::SMatDeclStrLowExpr< MT, SO > | Expression object for the explicit strictly lower declaration of sparse matrices |
►Cblaze::Matrix< SMatDeclStrUppExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatDeclStrUppExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatDeclStrUppExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< SparseMatrix< SMatDeclStrUppExpr< MT, SO >, SO > > | |
►Cblaze::DeclStrUppExpr< SparseMatrix< SMatDeclStrUppExpr< MT, SO >, SO > > | |
Cblaze::SMatDeclStrUppExpr< MT, SO > | Expression object for the explicit strictly upper declaration of sparse matrices |
►Cblaze::Matrix< SMatDeclSymExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatDeclSymExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatDeclSymExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< SparseMatrix< SMatDeclSymExpr< MT, SO >, SO > > | |
►Cblaze::DeclSymExpr< SparseMatrix< SMatDeclSymExpr< MT, SO >, SO > > | |
Cblaze::SMatDeclSymExpr< MT, SO > | Expression object for the explicit symmetry declaration of sparse matrices |
►Cblaze::Matrix< SMatDeclUniLowExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatDeclUniLowExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatDeclUniLowExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< SparseMatrix< SMatDeclUniLowExpr< MT, SO >, SO > > | |
►Cblaze::DeclUniLowExpr< SparseMatrix< SMatDeclUniLowExpr< MT, SO >, SO > > | |
Cblaze::SMatDeclUniLowExpr< MT, SO > | Expression object for the explicit unilower declaration of sparse matrices |
►Cblaze::Matrix< SMatDeclUniUppExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatDeclUniUppExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatDeclUniUppExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< SparseMatrix< SMatDeclUniUppExpr< MT, SO >, SO > > | |
►Cblaze::DeclUniUppExpr< SparseMatrix< SMatDeclUniUppExpr< MT, SO >, SO > > | |
Cblaze::SMatDeclUniUppExpr< MT, SO > | Expression object for the explicit uniupper declaration of sparse matrices |
►Cblaze::Matrix< SMatDeclUppExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatDeclUppExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatDeclUppExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< SparseMatrix< SMatDeclUppExpr< MT, SO >, SO > > | |
►Cblaze::DeclUppExpr< SparseMatrix< SMatDeclUppExpr< MT, SO >, SO > > | |
Cblaze::SMatDeclUppExpr< MT, SO > | Expression object for the explicit upper declaration of sparse matrices |
►Cblaze::Matrix< SMatDMatKronExpr< MT1, MT2, SO >, SO > | |
►Cblaze::SparseMatrix< SMatDMatKronExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatDMatKronExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::KronExpr< SparseMatrix< SMatDMatKronExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::MatMatKronExpr< SparseMatrix< SMatDMatKronExpr< MT1, MT2, SO >, SO > > | |
Cblaze::SMatDMatKronExpr< MT1, MT2, SO > | Expression object for sparse matrix-dense matrix Kronecker product |
►Cblaze::Matrix< SMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, SO > | |
►Cblaze::DenseMatrix< SMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > | |
►Cblaze::Expression< DenseMatrix< SMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MultExpr< DenseMatrix< SMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< SMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
Cblaze::SMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for sparse matrix-dense matrix multiplications |
►Cblaze::Matrix< SMatDMatSchurExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatDMatSchurExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< SMatDMatSchurExpr< MT1, MT2 >, false > > | |
►Cblaze::SchurExpr< SparseMatrix< SMatDMatSchurExpr< MT1, MT2 >, false > > | |
Cblaze::SMatDMatSchurExpr< MT1, MT2 > | Expression object for sparse matrix-dense matrix Schur product |
►Cblaze::Matrix< SMatDMatSubExpr< MT1, MT2, SO >, SO > | |
►Cblaze::DenseMatrix< SMatDMatSubExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< SMatDMatSubExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::SubExpr< DenseMatrix< SMatDMatSubExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::MatMatSubExpr< DenseMatrix< SMatDMatSubExpr< MT1, MT2, SO >, SO > > | |
Cblaze::SMatDMatSubExpr< MT1, MT2, SO > | Expression object for sparse matrix-dense matrix subtractions |
►Cblaze::Matrix< SMatEvalExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatEvalExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatEvalExpr< MT, SO >, SO > > | |
►Cblaze::EvalExpr< SparseMatrix< SMatEvalExpr< MT, SO >, SO > > | |
►Cblaze::MatEvalExpr< SparseMatrix< SMatEvalExpr< MT, SO >, SO > > | |
Cblaze::SMatEvalExpr< MT, SO > | Expression object for the forced evaluation of sparse matrices |
►Cblaze::Matrix< SMatMapExpr< MT, OP, SO >, SO > | |
►Cblaze::SparseMatrix< SMatMapExpr< MT, OP, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatMapExpr< MT, OP, SO >, SO > > | |
►Cblaze::UnaryMapExpr< SparseMatrix< SMatMapExpr< MT, OP, SO >, SO > > | |
►Cblaze::MatMapExpr< SparseMatrix< SMatMapExpr< MT, OP, SO >, SO > > | |
Cblaze::SMatMapExpr< MT, OP, SO > | Expression object for the sparse matrix map() function |
►Cblaze::Matrix< SMatNoAliasExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatNoAliasExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatNoAliasExpr< MT, SO >, SO > > | |
►Cblaze::NoAliasExpr< SparseMatrix< SMatNoAliasExpr< MT, SO >, SO > > | |
►Cblaze::MatNoAliasExpr< SparseMatrix< SMatNoAliasExpr< MT, SO >, SO > > | |
Cblaze::SMatNoAliasExpr< MT, SO > | Expression object for the non-aliased evaluation of sparse matrices |
►Cblaze::Matrix< SMatRepeatExpr< MT, SO, CRAs... >, SO > | |
►Cblaze::SparseMatrix< SMatRepeatExpr< MT, SO, CRAs... >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatRepeatExpr< MT, SO, CRAs... >, SO > > | |
►Cblaze::RepeatExpr< SparseMatrix< SMatRepeatExpr< MT, SO, CRAs... >, SO > > | |
►Cblaze::MatRepeatExpr< SparseMatrix< SMatRepeatExpr< MT, SO, CRAs... >, SO >, CRAs... > | |
Cblaze::SMatRepeatExpr< MT, SO, CRAs > | Expression object for the sparse matrix repeat() function |
►Cblaze::Matrix< SMatScalarDivExpr< MT, ST, SO >, SO > | |
►Cblaze::SparseMatrix< SMatScalarDivExpr< MT, ST, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatScalarDivExpr< MT, ST, SO >, SO > > | |
►Cblaze::DivExpr< SparseMatrix< SMatScalarDivExpr< MT, ST, SO >, SO > > | |
►Cblaze::MatScalarDivExpr< SparseMatrix< SMatScalarDivExpr< MT, ST, SO >, SO > > | |
Cblaze::SMatScalarDivExpr< MT, ST, SO > | Expression object for sparse matrix-scalar divisions |
►Cblaze::Matrix< SMatScalarMultExpr< MT, ST, SO >, SO > | |
►Cblaze::SparseMatrix< SMatScalarMultExpr< MT, ST, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatScalarMultExpr< MT, ST, SO >, SO > > | |
►Cblaze::MultExpr< SparseMatrix< SMatScalarMultExpr< MT, ST, SO >, SO > > | |
►Cblaze::MatScalarMultExpr< SparseMatrix< SMatScalarMultExpr< MT, ST, SO >, SO > > | |
Cblaze::SMatScalarMultExpr< MT, ST, SO > | Expression object for sparse matrix-scalar multiplications |
►Cblaze::Matrix< SMatSerialExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatSerialExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatSerialExpr< MT, SO >, SO > > | |
►Cblaze::SerialExpr< SparseMatrix< SMatSerialExpr< MT, SO >, SO > > | |
►Cblaze::MatSerialExpr< SparseMatrix< SMatSerialExpr< MT, SO >, SO > > | |
Cblaze::SMatSerialExpr< MT, SO > | Expression object for the forced serial evaluation of sparse matrices |
►Cblaze::Matrix< SMatSMatAddExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatSMatAddExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< SMatSMatAddExpr< MT1, MT2 >, false > > | |
►Cblaze::AddExpr< SparseMatrix< SMatSMatAddExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatAddExpr< SparseMatrix< SMatSMatAddExpr< MT1, MT2 >, false > > | |
Cblaze::SMatSMatAddExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix additions |
►Cblaze::Matrix< SMatSMatKronExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatSMatKronExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< SMatSMatKronExpr< MT1, MT2 >, false > > | |
►Cblaze::KronExpr< SparseMatrix< SMatSMatKronExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatKronExpr< SparseMatrix< SMatSMatKronExpr< MT1, MT2 >, false > > | |
Cblaze::SMatSMatKronExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix Kronecker product |
►Cblaze::Matrix< SMatSMatMultExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatSMatMultExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< SMatSMatMultExpr< MT1, MT2 >, false > > | |
►Cblaze::MultExpr< SparseMatrix< SMatSMatMultExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatMultExpr< SparseMatrix< SMatSMatMultExpr< MT1, MT2 >, false > > | |
Cblaze::SMatSMatMultExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix multiplications |
►Cblaze::Matrix< SMatSMatSchurExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatSMatSchurExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< SMatSMatSchurExpr< MT1, MT2 >, false > > | |
►Cblaze::SchurExpr< SparseMatrix< SMatSMatSchurExpr< MT1, MT2 >, false > > | |
Cblaze::SMatSMatSchurExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix Schur product |
►Cblaze::Matrix< SMatSMatSubExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatSMatSubExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< SMatSMatSubExpr< MT1, MT2 >, false > > | |
►Cblaze::SubExpr< SparseMatrix< SMatSMatSubExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatSubExpr< SparseMatrix< SMatSMatSubExpr< MT1, MT2 >, false > > | |
Cblaze::SMatSMatSubExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix subtractions |
►Cblaze::Matrix< SMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, SO > | |
►Cblaze::DenseMatrix< SMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > | |
►Cblaze::Expression< DenseMatrix< SMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MultExpr< DenseMatrix< SMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< SMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
Cblaze::SMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for sparse matrix-transpose dense matrix multiplications |
►Cblaze::Matrix< SMatTDMatSubExpr< MT1, MT2 >, SO > | |
►Cblaze::DenseMatrix< SMatTDMatSubExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< DenseMatrix< SMatTDMatSubExpr< MT1, MT2 >, true > > | |
►Cblaze::SubExpr< DenseMatrix< SMatTDMatSubExpr< MT1, MT2 >, true > > | |
►Cblaze::MatMatSubExpr< DenseMatrix< SMatTDMatSubExpr< MT1, MT2 >, true > > | |
Cblaze::SMatTDMatSubExpr< MT1, MT2 > | Expression object for sparse matrix-transpose dense matrix subtractions |
►Cblaze::Matrix< SMatTransExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatTransExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatTransExpr< MT, SO >, SO > > | |
►Cblaze::TransExpr< SparseMatrix< SMatTransExpr< MT, SO >, SO > > | |
►Cblaze::MatTransExpr< SparseMatrix< SMatTransExpr< MT, SO >, SO > > | |
Cblaze::SMatTransExpr< MT, SO > | Expression object for sparse matrix transpositions |
►Cblaze::Matrix< SMatTransposer< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatTransposer< MT, SO >, SO > | |
Cblaze::SMatTransposer< MT, SO > | Expression object for the transposition of a sparse matrix |
►Cblaze::Matrix< SMatTSMatAddExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatTSMatAddExpr< MT1, MT2 >, IsZero_v< MT1 > > | |
►Cblaze::Expression< SparseMatrix< SMatTSMatAddExpr< MT1, MT2 >, IsZero_v< MT1 > > > | |
►Cblaze::AddExpr< SparseMatrix< SMatTSMatAddExpr< MT1, MT2 >, IsZero_v< MT1 > > > | |
►Cblaze::MatMatAddExpr< SparseMatrix< SMatTSMatAddExpr< MT1, MT2 >, IsZero_v< MT1 > > > | |
Cblaze::SMatTSMatAddExpr< MT1, MT2 > | Expression object for sparse matrix-transpose sparse matrix additions |
►Cblaze::Matrix< SMatTSMatKronExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatTSMatKronExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< SparseMatrix< SMatTSMatKronExpr< MT1, MT2 >, true > > | |
►Cblaze::KronExpr< SparseMatrix< SMatTSMatKronExpr< MT1, MT2 >, true > > | |
►Cblaze::MatMatKronExpr< SparseMatrix< SMatTSMatKronExpr< MT1, MT2 >, true > > | |
Cblaze::SMatTSMatKronExpr< MT1, MT2 > | Expression object for sparse matrix-transpose sparse matrix Kronecker product |
►Cblaze::Matrix< SMatTSMatMultExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatTSMatMultExpr< MT1, MT2 >, IsIdentity_v< MT1 > > | |
►Cblaze::Expression< SparseMatrix< SMatTSMatMultExpr< MT1, MT2 >, IsIdentity_v< MT1 > > > | |
►Cblaze::MultExpr< SparseMatrix< SMatTSMatMultExpr< MT1, MT2 >, IsIdentity_v< MT1 > > > | |
►Cblaze::MatMatMultExpr< SparseMatrix< SMatTSMatMultExpr< MT1, MT2 >, IsIdentity_v< MT1 > > > | |
Cblaze::SMatTSMatMultExpr< MT1, MT2 > | Expression object for sparse matrix-transpose sparse matrix multiplications |
►Cblaze::Matrix< SMatTSMatSchurExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatTSMatSchurExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< SMatTSMatSchurExpr< MT1, MT2 >, false > > | |
►Cblaze::SchurExpr< SparseMatrix< SMatTSMatSchurExpr< MT1, MT2 >, false > > | |
Cblaze::SMatTSMatSchurExpr< MT1, MT2 > | Expression object for sparse matrix-transpose sparse matrix Schur product |
►Cblaze::Matrix< SMatTSMatSubExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatTSMatSubExpr< MT1, MT2 >, IsZero_v< MT1 > > | |
►Cblaze::Expression< SparseMatrix< SMatTSMatSubExpr< MT1, MT2 >, IsZero_v< MT1 > > > | |
►Cblaze::SubExpr< SparseMatrix< SMatTSMatSubExpr< MT1, MT2 >, IsZero_v< MT1 > > > | |
►Cblaze::MatMatSubExpr< SparseMatrix< SMatTSMatSubExpr< MT1, MT2 >, IsZero_v< MT1 > > > | |
Cblaze::SMatTSMatSubExpr< MT1, MT2 > | Expression object for sparse matrix-transpose sparse matrix subtractions |
►Cblaze::Matrix< StaticMatrix< Type, M, N, SO, AF, PF, Tag >, SO > | |
►Cblaze::DenseMatrix< StaticMatrix< Type, M, N, SO, AF, PF, Tag >, SO > | |
Cblaze::StaticMatrix< Type, M, N, SO, AF, PF, Tag > | Efficient implementation of a fixed-sized matrix |
►Cblaze::Matrix< SVecDVecOuterExpr< VT1, VT2 >, SO > | |
►Cblaze::SparseMatrix< SVecDVecOuterExpr< VT1, VT2 >, true > | |
►Cblaze::Expression< SparseMatrix< SVecDVecOuterExpr< VT1, VT2 >, true > > | |
►Cblaze::MultExpr< SparseMatrix< SVecDVecOuterExpr< VT1, VT2 >, true > > | |
►Cblaze::VecTVecMultExpr< SparseMatrix< SVecDVecOuterExpr< VT1, VT2 >, true > > | |
Cblaze::SVecDVecOuterExpr< VT1, VT2 > | Expression object for sparse vector-dense vector outer products |
►Cblaze::Matrix< SVecExpandExpr< VT, TF, CEAs... >, SO > | |
►Cblaze::SparseMatrix< SVecExpandExpr< VT, TF, CEAs... >, !TF > | |
►Cblaze::Expression< SparseMatrix< SVecExpandExpr< VT, TF, CEAs... >, !TF > > | |
►Cblaze::ExpandExpr< SparseMatrix< SVecExpandExpr< VT, TF, CEAs... >, !TF > > | |
►Cblaze::VecExpandExpr< SparseMatrix< SVecExpandExpr< VT, TF, CEAs... >, !TF >, CEAs... > | |
Cblaze::SVecExpandExpr< VT, TF, CEAs > | Expression object for sparse vector expansion |
►Cblaze::Matrix< SVecSVecOuterExpr< VT1, VT2 >, SO > | |
►Cblaze::SparseMatrix< SVecSVecOuterExpr< VT1, VT2 >, false > | |
►Cblaze::Expression< SparseMatrix< SVecSVecOuterExpr< VT1, VT2 >, false > > | |
►Cblaze::MultExpr< SparseMatrix< SVecSVecOuterExpr< VT1, VT2 >, false > > | |
►Cblaze::VecTVecMultExpr< SparseMatrix< SVecSVecOuterExpr< VT1, VT2 >, false > > | |
Cblaze::SVecSVecOuterExpr< VT1, VT2 > | Expression object for sparse vector-sparse vector outer products |
►Cblaze::Matrix< TDMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, SO > | |
►Cblaze::DenseMatrix< TDMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > | |
►Cblaze::Expression< DenseMatrix< TDMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MultExpr< DenseMatrix< TDMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< TDMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
Cblaze::TDMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for transpose dense matrix-dense matrix multiplications |
►Cblaze::Matrix< TDMatSMatAddExpr< MT1, MT2 >, SO > | |
►Cblaze::DenseMatrix< TDMatSMatAddExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< DenseMatrix< TDMatSMatAddExpr< MT1, MT2 >, true > > | |
►Cblaze::AddExpr< DenseMatrix< TDMatSMatAddExpr< MT1, MT2 >, true > > | |
►Cblaze::MatMatAddExpr< DenseMatrix< TDMatSMatAddExpr< MT1, MT2 >, true > > | |
Cblaze::TDMatSMatAddExpr< MT1, MT2 > | Expression object for dense matrix-sparse matrix additions |
►Cblaze::Matrix< TDMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, SO > | |
►Cblaze::DenseMatrix< TDMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > | |
►Cblaze::Expression< DenseMatrix< TDMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MultExpr< DenseMatrix< TDMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< TDMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
Cblaze::TDMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for transpose dense matrix-sparse matrix multiplications |
►Cblaze::Matrix< TDMatSMatSubExpr< MT1, MT2 >, SO > | |
►Cblaze::DenseMatrix< TDMatSMatSubExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< DenseMatrix< TDMatSMatSubExpr< MT1, MT2 >, true > > | |
►Cblaze::SubExpr< DenseMatrix< TDMatSMatSubExpr< MT1, MT2 >, true > > | |
►Cblaze::MatMatSubExpr< DenseMatrix< TDMatSMatSubExpr< MT1, MT2 >, true > > | |
Cblaze::TDMatSMatSubExpr< MT1, MT2 > | Expression object for transpose dense matrix-sparse matrix subtractions |
►Cblaze::Matrix< TDMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, SO > | |
►Cblaze::DenseMatrix< TDMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > | |
►Cblaze::Expression< DenseMatrix< TDMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MultExpr< DenseMatrix< TDMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< TDMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
Cblaze::TDMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for transpose dense matrix-transpose dense matrix multiplications |
►Cblaze::Matrix< TDMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, SO > | |
►Cblaze::DenseMatrix< TDMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > | |
►Cblaze::Expression< DenseMatrix< TDMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MultExpr< DenseMatrix< TDMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< TDMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
Cblaze::TDMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for transpose dense matrix-transpose sparse matrix multiplications |
►Cblaze::Matrix< TSMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, SO > | |
►Cblaze::DenseMatrix< TSMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > | |
►Cblaze::Expression< DenseMatrix< TSMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MultExpr< DenseMatrix< TSMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< TSMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
Cblaze::TSMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for transpose sparse matrix-dense matrix multiplications |
►Cblaze::Matrix< TSMatDMatSchurExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatDMatSchurExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< SparseMatrix< TSMatDMatSchurExpr< MT1, MT2 >, true > > | |
►Cblaze::SchurExpr< SparseMatrix< TSMatDMatSchurExpr< MT1, MT2 >, true > > | |
Cblaze::TSMatDMatSchurExpr< MT1, MT2 > | Expression object for transpose sparse matrix-dense matrix Schur product |
►Cblaze::Matrix< TSMatDMatSubExpr< MT1, MT2 >, SO > | |
►Cblaze::DenseMatrix< TSMatDMatSubExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< DenseMatrix< TSMatDMatSubExpr< MT1, MT2 >, false > > | |
►Cblaze::SubExpr< DenseMatrix< TSMatDMatSubExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatSubExpr< DenseMatrix< TSMatDMatSubExpr< MT1, MT2 >, false > > | |
Cblaze::TSMatDMatSubExpr< MT1, MT2 > | Expression object for transpose sparse matrix-dense matrix subtractions |
►Cblaze::Matrix< TSMatSMatKronExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatSMatKronExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< TSMatSMatKronExpr< MT1, MT2 >, false > > | |
►Cblaze::KronExpr< SparseMatrix< TSMatSMatKronExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatKronExpr< SparseMatrix< TSMatSMatKronExpr< MT1, MT2 >, false > > | |
Cblaze::TSMatSMatKronExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix Kronecker product |
►Cblaze::Matrix< TSMatSMatMultExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatSMatMultExpr< MT1, MT2 >, !IsIdentity_v< MT1 > > | |
►Cblaze::Expression< SparseMatrix< TSMatSMatMultExpr< MT1, MT2 >, !IsIdentity_v< MT1 > > > | |
►Cblaze::MultExpr< SparseMatrix< TSMatSMatMultExpr< MT1, MT2 >, !IsIdentity_v< MT1 > > > | |
►Cblaze::MatMatMultExpr< SparseMatrix< TSMatSMatMultExpr< MT1, MT2 >, !IsIdentity_v< MT1 > > > | |
Cblaze::TSMatSMatMultExpr< MT1, MT2 > | Expression object for transpose sparse matrix-sparse matrix multiplications |
►Cblaze::Matrix< TSMatSMatSchurExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatSMatSchurExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< TSMatSMatSchurExpr< MT1, MT2 >, false > > | |
►Cblaze::SchurExpr< SparseMatrix< TSMatSMatSchurExpr< MT1, MT2 >, false > > | |
Cblaze::TSMatSMatSchurExpr< MT1, MT2 > | Expression object for transpose sparse matrix-sparse matrix Schur products |
►Cblaze::Matrix< TSMatSMatSubExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatSMatSubExpr< MT1, MT2 >, IsZero_v< MT2 > > | |
►Cblaze::Expression< SparseMatrix< TSMatSMatSubExpr< MT1, MT2 >, IsZero_v< MT2 > > > | |
►Cblaze::SubExpr< SparseMatrix< TSMatSMatSubExpr< MT1, MT2 >, IsZero_v< MT2 > > > | |
►Cblaze::MatMatSubExpr< SparseMatrix< TSMatSMatSubExpr< MT1, MT2 >, IsZero_v< MT2 > > > | |
Cblaze::TSMatSMatSubExpr< MT1, MT2 > | Expression object for transpose sparse matrix-sparse matrix subtractions |
►Cblaze::Matrix< TSMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, SO > | |
►Cblaze::DenseMatrix< TSMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > | |
►Cblaze::Expression< DenseMatrix< TSMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MultExpr< DenseMatrix< TSMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< TSMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
Cblaze::TSMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for transpose sparse matrix-transpose dense matrix multiplications |
►Cblaze::Matrix< TSMatTSMatAddExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatTSMatAddExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< SparseMatrix< TSMatTSMatAddExpr< MT1, MT2 >, true > > | |
►Cblaze::AddExpr< SparseMatrix< TSMatTSMatAddExpr< MT1, MT2 >, true > > | |
►Cblaze::MatMatAddExpr< SparseMatrix< TSMatTSMatAddExpr< MT1, MT2 >, true > > | |
Cblaze::TSMatTSMatAddExpr< MT1, MT2 > | Expression object for transpose sparse matrix-transpose sparse matrix additions |
►Cblaze::Matrix< TSMatTSMatKronExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatTSMatKronExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< SparseMatrix< TSMatTSMatKronExpr< MT1, MT2 >, true > > | |
►Cblaze::KronExpr< SparseMatrix< TSMatTSMatKronExpr< MT1, MT2 >, true > > | |
►Cblaze::MatMatKronExpr< SparseMatrix< TSMatTSMatKronExpr< MT1, MT2 >, true > > | |
Cblaze::TSMatTSMatKronExpr< MT1, MT2 > | Expression object for transpose sparse matrix-transpose sparse matrix Kronecker product |
►Cblaze::Matrix< TSMatTSMatMultExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatTSMatMultExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< SparseMatrix< TSMatTSMatMultExpr< MT1, MT2 >, true > > | |
►Cblaze::MultExpr< SparseMatrix< TSMatTSMatMultExpr< MT1, MT2 >, true > > | |
►Cblaze::MatMatMultExpr< SparseMatrix< TSMatTSMatMultExpr< MT1, MT2 >, true > > | |
Cblaze::TSMatTSMatMultExpr< MT1, MT2 > | Expression object for transpose sparse matrix-transpose sparse matrix multiplications |
►Cblaze::Matrix< TSMatTSMatSchurExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatTSMatSchurExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< SparseMatrix< TSMatTSMatSchurExpr< MT1, MT2 >, true > > | |
►Cblaze::SchurExpr< SparseMatrix< TSMatTSMatSchurExpr< MT1, MT2 >, true > > | |
Cblaze::TSMatTSMatSchurExpr< MT1, MT2 > | Expression object for transpose sparse matrix-transpose sparse matrix Schur product |
►Cblaze::Matrix< TSMatTSMatSubExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatTSMatSubExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< SparseMatrix< TSMatTSMatSubExpr< MT1, MT2 >, true > > | |
►Cblaze::SubExpr< SparseMatrix< TSMatTSMatSubExpr< MT1, MT2 >, true > > | |
►Cblaze::MatMatSubExpr< SparseMatrix< TSMatTSMatSubExpr< MT1, MT2 >, true > > | |
Cblaze::TSMatTSMatSubExpr< MT1, MT2 > | Expression object for transpose sparse matrix-transpose sparse matrix subtractions |
►Cblaze::Matrix< UniformMatrix< Type, SO, Tag >, SO > | |
►Cblaze::DenseMatrix< UniformMatrix< Type, SO, Tag >, SO > | |
►Cblaze::Expression< DenseMatrix< UniformMatrix< Type, SO, Tag >, SO > > | |
Cblaze::UniformMatrix< Type, SO, Tag > | Efficient implementation of a uniform matrix |
►Cblaze::Matrix< ZeroMatrix< Type, SO, Tag >, SO > | |
►Cblaze::SparseMatrix< ZeroMatrix< Type, SO, Tag >, SO > | |
►Cblaze::Expression< SparseMatrix< ZeroMatrix< Type, SO, Tag >, SO > > | |
Cblaze::ZeroMatrix< Type, SO, Tag > | Efficient implementation of an zero matrix |
Cblaze::MatrixSerializer | Serializer for dense and sparse matrices |
Cblaze::Max | Generic wrapper for the max() function |
Cblaze::MaxSizeHelper1< typename, size_t, typename > | |
►Cblaze::MaxSizeHelper1< T, N > | |
Cblaze::MaxSize< T, N > | Compile time evaluation of the maximum size of vectors and matrices |
Cblaze::MaxSizeHelper2< typename, size_t, typename > | |
Cblaze::Min | Generic wrapper for the min() function |
Cblaze::Minmax | Generic wrapper for the minmax() function |
Cblaze::ModuloAssign | Generic wrapper for modulo assignment |
►CMT | |
►Cblaze::Expression< MT > | |
►Cblaze::AddExpr< MT > | |
Cblaze::MatMatAddExpr< MT > | Base class for all matrix/matrix addition expression templates |
►Cblaze::BinaryMapExpr< MT > | |
Cblaze::MatMatMapExpr< MT > | Base class for all binary matrix map expression templates |
Cblaze::VecTVecMapExpr< MT > | Base class for all outer map expression templates |
►Cblaze::DeclExpr< MT > | |
Cblaze::DeclDiagExpr< MT > | Base class for all decldiag expression templates |
Cblaze::DeclHermExpr< MT > | Base class for all declherm expression templates |
Cblaze::DeclLowExpr< MT > | Base class for all decllow expression templates |
Cblaze::DeclStrLowExpr< MT > | Base class for all declstrlow expression templates |
Cblaze::DeclStrUppExpr< MT > | Base class for all declstrupp expression templates |
Cblaze::DeclSymExpr< MT > | Base class for all declsym expression templates |
Cblaze::DeclUniLowExpr< MT > | Base class for all declunilow expression templates |
Cblaze::DeclUniUppExpr< MT > | Base class for all decluniupp expression templates |
Cblaze::DeclUppExpr< MT > | Base class for all declupp expression templates |
►Cblaze::DivExpr< MT > | |
Cblaze::MatScalarDivExpr< MT > | Base class for all matrix/scalar division expression templates |
►Cblaze::EvalExpr< MT > | |
Cblaze::MatEvalExpr< MT > | Base class for all matrix evaluation expression templates |
►Cblaze::ExpandExpr< MT > | |
Cblaze::VecExpandExpr< MT, CEAs > | Base class for all vector expansion expression templates |
►Cblaze::GenExpr< MT > | |
Cblaze::MatGenExpr< MT > | Base class for all matrix generator expression templates |
►Cblaze::MultExpr< MT > | |
Cblaze::MatMatMultExpr< MT > | Base class for all matrix/matrix multiplication expression templates |
Cblaze::MatScalarMultExpr< MT > | Base class for all matrix/scalar multiplication expression templates |
Cblaze::VecTVecMultExpr< MT > | Base class for all outer product expression templates |
►Cblaze::NoAliasExpr< MT > | |
Cblaze::MatNoAliasExpr< MT > | Base class for all matrix no-alias expression templates |
►Cblaze::NoSIMDExpr< MT > | |
Cblaze::MatNoSIMDExpr< MT > | Base class for all matrix no-SIMD expression templates |
►Cblaze::RepeatExpr< MT > | |
Cblaze::MatRepeatExpr< MT, CEAs > | Base class for all matrix repeat expression templates |
►Cblaze::SerialExpr< MT > | |
Cblaze::MatSerialExpr< MT > | Base class for all matrix serial evaluation expression templates |
►Cblaze::SolveExpr< MT > | |
Cblaze::MatMatSolveExpr< MT > | Base class for all multi LSE solver expression templates |
►Cblaze::SubExpr< MT > | |
Cblaze::MatMatSubExpr< MT > | Base class for all matrix/matrix subtraction expression templates |
►Cblaze::TransExpr< MT > | |
Cblaze::MatTransExpr< MT > | Base class for all matrix transposition expression templates |
►Cblaze::UnaryMapExpr< MT > | |
Cblaze::MatMapExpr< MT > | Base class for all unary matrix map expression templates |
Cblaze::EigenExpr< MT > | Base class for all eigenvalue expression templates |
►Cblaze::KronExpr< MT > | Base class for all Kron product expression templates |
Cblaze::MatMatKronExpr< MT > | Base class for all matrix/matrix Kronecker expression templates |
Cblaze::MatExpExpr< MT > | Base class for all matrix exponential expression templates |
Cblaze::MatInvExpr< MT > | Base class for all matrix inversion expression templates |
Cblaze::SVDExpr< MT > | Base class for all singular value expression templates |
Cblaze::SchurExpr< MT > | Base class for all Schur product expression templates |
Cblaze::Mult | Generic wrapper for the multiplication operator |
Cblaze::MultAssign | Generic wrapper for multiplication assignment |
Cblaze::NegativeAccuracy< A > | Negative computation accuracy for floating point data types |
Cblaze::NegativeEpsilon< E > | Negative epsilon value for floating point data types |
Cblaze::NegativeInfinity< I > | Negative infinity for built-in data types |
Cblaze::NoAlias | Generic wrapper for the noalias() function |
Cblaze::NoDelete | No-delete policy class |
►Cblaze::NonCopyable | Base class for non-copyable class instances |
Cblaze::MemoryPool< Type, Blocksize > | Memory pool for small objects |
Cblaze::Singleton< T, D1, D2, D3, D4, D5, D6, D7, D8 > | Base class for all lifetime managed singletons |
Cblaze::Thread< TT, MT, LT, CT > | Implementation of a single thread of execution |
Cblaze::ThreadPool< TT, MT, LT, CT > | Implementation of a thread pool |
►Cblaze::NonCreatable | Base class for non-creatable (static) classes |
Cblaze::Random< RNG > | Random number generator |
Cblaze::NoneSuch | Default result type for the Detected_t type trait |
Cblaze::Noop | Generic wrapper for the null function |
Cblaze::NoSIMD | Generic wrapper for the nosimd() function |
Cblaze::Not | Generic wrapper for the logical NOT operator |
Cblaze::NullAllocator< T > | Allocator returning nullptr |
Cblaze::NullType | Utility type for generic codes |
►Cblaze::Operation | Base class for all operational expression templates |
►Cblaze::Computation | Base class for all compute expression templates |
Cblaze::DMatDMatAddExpr< MT1, MT2, SO > | Expression object for dense matrix-dense matrix additions |
Cblaze::DMatDMatKronExpr< MT1, MT2, SO > | Expression object for dense matrix-dense matrix Kronecker products |
Cblaze::DMatDMatMapExpr< MT1, MT2, OP, SO > | Expression object for the dense matrix-dense matrix map() function |
Cblaze::DMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for dense matrix-dense matrix multiplications |
Cblaze::DMatDMatSchurExpr< MT1, MT2, SO > | Expression object for dense matrix-dense matrix Schur products |
Cblaze::DMatDMatSolveExpr< MT1, MT2, SO > | Expression object for dense matrix-dense matrix solvers |
Cblaze::DMatDMatSubExpr< MT1, MT2, SO > | Expression object for dense matrix-dense matrix subtractions |
Cblaze::DMatDVecMultExpr< MT, VT > | Expression object for dense matrix-dense vector multiplications |
Cblaze::DMatDVecSolveExpr< MT, VT, TF > | Expression object for dense matrix-dense vector solvers |
Cblaze::DMatEigenExpr< MT, SO > | Expression object for dense matrix eigenvalue solvers |
Cblaze::DMatEvalExpr< MT, SO > | Expression object for the forced evaluation of dense matrices |
Cblaze::DMatExpExpr< MT, SO > | Expression object for dense matrix exponential |
Cblaze::DMatGenExpr< MT, OP, SO > | Expression object for the dense matrix generate() function |
Cblaze::DMatInvExpr< MT, SO > | Expression object for dense matrix inversions |
Cblaze::DMatMapExpr< MT, OP, SO > | Expression object for the dense matrix map() function |
Cblaze::DMatReduceExpr< MT, OP, columnwise > | Expression object for column-wise row-major dense matrix reduction operations |
Cblaze::DMatReduceExpr< MT, OP, rowwise > | Expression object for row-wise row-major dense matrix reduction operations |
Cblaze::DMatSMatAddExpr< MT1, MT2, SO > | Expression object for dense matrix-sparse matrix additions |
Cblaze::DMatSMatKronExpr< MT1, MT2, SO > | Expression object for dense matrix-sparse matrix Kronecker product |
Cblaze::DMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for dense matrix-sparse matrix multiplications |
Cblaze::DMatSMatSubExpr< MT1, MT2, SO > | Expression object for dense matrix-sparse matrix subtractions |
Cblaze::DMatSVDExpr< MT, SO > | Expression object for dense matrix singular value solvers |
Cblaze::DMatSVecMultExpr< MT, VT > | Expression object for dense matrix-sparse vector multiplications |
Cblaze::DMatScalarDivExpr< MT, ST, SO > | Expression object for divisions of a dense matrix by a scalar |
Cblaze::DMatScalarMultExpr< MT, ST, SO > | Expression object for dense matrix-scalar multiplications |
Cblaze::DMatSerialExpr< MT, SO > | Expression object for the forced serial evaluation of dense matrices |
Cblaze::DMatTDMatAddExpr< MT1, MT2 > | Expression object for dense matrix-transpose dense matrix additions |
Cblaze::DMatTDMatMapExpr< MT1, MT2, OP > | Expression object for the dense matrix/tranpose dense matrix map() function |
Cblaze::DMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for dense matrix-transpose dense matrix multiplications |
Cblaze::DMatTDMatSchurExpr< MT1, MT2 > | Expression object for dense matrix-transpose dense matrix Schur product |
Cblaze::DMatTDMatSubExpr< MT1, MT2 > | Expression object for dense matrix-transpose dense matrix subtractions |
Cblaze::DMatTSMatAddExpr< MT1, MT2 > | Expression object for dense matrix-sparse matrix additions |
Cblaze::DMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for dense matrix-transpose sparse matrix multiplications |
Cblaze::DMatTSMatSubExpr< MT1, MT2 > | Expression object for dense matrix-transpose sparse matrix subtractions |
Cblaze::DVecDVecAddExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector additions |
Cblaze::DVecDVecCrossExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector cross products |
Cblaze::DVecDVecDivExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector divisions |
Cblaze::DVecDVecKronExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector Kronecker product |
Cblaze::DVecDVecMapExpr< VT1, VT2, OP, TF > | Expression object for the dense vector-dense vector map() function |
Cblaze::DVecDVecMultExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector multiplications |
Cblaze::DVecDVecOuterExpr< VT1, VT2, OP > | Expression object for the dense vector-dense vector outer map() function |
Cblaze::DVecDVecSubExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector subtractions |
Cblaze::DVecEvalExpr< VT, TF > | Expression object for the forced evaluation of dense vectors |
Cblaze::DVecGenExpr< VT, OP, TF > | Expression object for the dense vector generate() function |
Cblaze::DVecMapExpr< VT, OP, TF > | Expression object for the dense vector map() function |
Cblaze::DVecSVecAddExpr< VT1, VT2, TF > | Expression object for dense vector-sparse vector additions |
Cblaze::DVecSVecCrossExpr< VT1, VT2, TF > | Expression object for dense vector-sparse vector cross products |
Cblaze::DVecSVecKronExpr< VT1, VT2, TF > | Expression object for dense vector-sparse vector Kronecker product |
Cblaze::DVecSVecMultExpr< VT1, VT2, TF > | Expression object for dense vector-sparse vector multiplications |
Cblaze::DVecSVecOuterExpr< VT1, VT2 > | Expression object for dense vector-sparse vector outer products |
Cblaze::DVecSVecSubExpr< VT1, VT2, TF > | Expression object for dense vector-sparse vector subtractions |
Cblaze::DVecScalarDivExpr< VT, ST, TF > | Expression object for divisions of a dense vector by a scalar |
Cblaze::DVecScalarMultExpr< VT, ST, TF > | Expression object for dense vector-scalar multiplications |
Cblaze::DVecSerialExpr< VT, TF > | Expression object for the forced serial evaluation of dense vectors |
Cblaze::SMatDMatKronExpr< MT1, MT2, SO > | Expression object for sparse matrix-dense matrix Kronecker product |
Cblaze::SMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for sparse matrix-dense matrix multiplications |
Cblaze::SMatDMatSchurExpr< MT1, MT2 > | Expression object for sparse matrix-dense matrix Schur product |
Cblaze::SMatDMatSubExpr< MT1, MT2, SO > | Expression object for sparse matrix-dense matrix subtractions |
Cblaze::SMatDVecMultExpr< MT, VT > | Expression object for sparse matrix-dense vector multiplications |
Cblaze::SMatEvalExpr< MT, SO > | Expression object for the forced evaluation of sparse matrices |
Cblaze::SMatMapExpr< MT, OP, SO > | Expression object for the sparse matrix map() function |
Cblaze::SMatReduceExpr< MT, OP, columnwise > | Expression object for column-wise row-major sparse matrix reduction operations |
Cblaze::SMatReduceExpr< MT, OP, rowwise > | Expression object for row-wise row-major sparse matrix reduction operations |
Cblaze::SMatSMatAddExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix additions |
Cblaze::SMatSMatKronExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix Kronecker product |
Cblaze::SMatSMatMultExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix multiplications |
Cblaze::SMatSMatSchurExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix Schur product |
Cblaze::SMatSMatSubExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix subtractions |
Cblaze::SMatSVecMultExpr< MT, VT > | Expression object for sparse matrix-sparse vector multiplications |
Cblaze::SMatScalarDivExpr< MT, ST, SO > | Expression object for sparse matrix-scalar divisions |
Cblaze::SMatScalarMultExpr< MT, ST, SO > | Expression object for sparse matrix-scalar multiplications |
Cblaze::SMatSerialExpr< MT, SO > | Expression object for the forced serial evaluation of sparse matrices |
Cblaze::SMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for sparse matrix-transpose dense matrix multiplications |
Cblaze::SMatTDMatSubExpr< MT1, MT2 > | Expression object for sparse matrix-transpose dense matrix subtractions |
Cblaze::SMatTSMatAddExpr< MT1, MT2 > | Expression object for sparse matrix-transpose sparse matrix additions |
Cblaze::SMatTSMatKronExpr< MT1, MT2 > | Expression object for sparse matrix-transpose sparse matrix Kronecker product |
Cblaze::SMatTSMatMultExpr< MT1, MT2 > | Expression object for sparse matrix-transpose sparse matrix multiplications |
Cblaze::SMatTSMatSchurExpr< MT1, MT2 > | Expression object for sparse matrix-transpose sparse matrix Schur product |
Cblaze::SMatTSMatSubExpr< MT1, MT2 > | Expression object for sparse matrix-transpose sparse matrix subtractions |
Cblaze::SMatVarExpr< MT, columnwise > | Expression object for the column-wise variance function on row-major sparse matrices |
Cblaze::SMatVarExpr< MT, rowwise > | Expression object for the row-wise variance function on row-major sparse matrices |
Cblaze::SVecDVecCrossExpr< VT1, VT2, TF > | Expression object for sparse vector-dense vector cross products |
Cblaze::SVecDVecDivExpr< VT1, VT2, TF > | Expression object for sparse vector-dense vector divisions |
Cblaze::SVecDVecKronExpr< VT1, VT2, TF > | Expression object for sparse vector-dense vector Kronecker products |
Cblaze::SVecDVecMultExpr< VT1, VT2, TF > | Expression object for sparse vector-dense vector multiplications |
Cblaze::SVecDVecOuterExpr< VT1, VT2 > | Expression object for sparse vector-dense vector outer products |
Cblaze::SVecDVecSubExpr< VT1, VT2, TF > | Expression object for sparse vector-dense vector subtractions |
Cblaze::SVecEvalExpr< VT, TF > | Expression object for the forced evaluation of sparse vectors |
Cblaze::SVecMapExpr< VT, OP, TF > | Expression object for the sparse vector map() function |
Cblaze::SVecSVecAddExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector additions |
Cblaze::SVecSVecCrossExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector cross products |
Cblaze::SVecSVecKronExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector Kronecker products |
Cblaze::SVecSVecMultExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector multiplications |
Cblaze::SVecSVecOuterExpr< VT1, VT2 > | Expression object for sparse vector-sparse vector outer products |
Cblaze::SVecSVecSubExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector subtractions |
Cblaze::SVecScalarDivExpr< VT, ST, TF > | Expression object for divisions of a sparse vector by a scalar |
Cblaze::SVecScalarMultExpr< VT, ST, TF > | Expression object for sparse vector-scalar multiplications |
Cblaze::SVecSerialExpr< VT, TF > | Expression object for the forced serial evaluation of sparse vectors |
Cblaze::TDMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for transpose dense matrix-dense matrix multiplications |
Cblaze::TDMatDVecMultExpr< MT, VT > | Expression object for transpose dense matrix-dense vector multiplications |
Cblaze::TDMatSMatAddExpr< MT1, MT2 > | Expression object for dense matrix-sparse matrix additions |
Cblaze::TDMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for transpose dense matrix-sparse matrix multiplications |
Cblaze::TDMatSMatSubExpr< MT1, MT2 > | Expression object for transpose dense matrix-sparse matrix subtractions |
Cblaze::TDMatSVecMultExpr< MT, VT > | Expression object for transpose dense matrix-sparse vector multiplications |
Cblaze::TDMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for transpose dense matrix-transpose dense matrix multiplications |
Cblaze::TDMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for transpose dense matrix-transpose sparse matrix multiplications |
Cblaze::TDVecDMatMultExpr< VT, MT > | Expression object for transpose dense vector-dense matrix multiplications |
Cblaze::TDVecSMatMultExpr< VT, MT > | Expression object for transpose dense vector-sparse matrix multiplications |
Cblaze::TDVecTDMatMultExpr< VT, MT > | Expression object for transpose dense vector-transpose dense matrix multiplications |
Cblaze::TDVecTSMatMultExpr< VT, MT > | Expression object for transpose dense vector-transpose sparse matrix multiplications |
Cblaze::TSMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for transpose sparse matrix-dense matrix multiplications |
Cblaze::TSMatDMatSchurExpr< MT1, MT2 > | Expression object for transpose sparse matrix-dense matrix Schur product |
Cblaze::TSMatDMatSubExpr< MT1, MT2 > | Expression object for transpose sparse matrix-dense matrix subtractions |
Cblaze::TSMatDVecMultExpr< MT, VT > | Expression object for transpose sparse matrix-dense vector multiplications |
Cblaze::TSMatSMatKronExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix Kronecker product |
Cblaze::TSMatSMatMultExpr< MT1, MT2 > | Expression object for transpose sparse matrix-sparse matrix multiplications |
Cblaze::TSMatSMatSchurExpr< MT1, MT2 > | Expression object for transpose sparse matrix-sparse matrix Schur products |
Cblaze::TSMatSMatSubExpr< MT1, MT2 > | Expression object for transpose sparse matrix-sparse matrix subtractions |
Cblaze::TSMatSVecMultExpr< MT, VT > | Expression object for sparse matrix-sparse vector multiplications |
Cblaze::TSMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for transpose sparse matrix-transpose dense matrix multiplications |
Cblaze::TSMatTSMatAddExpr< MT1, MT2 > | Expression object for transpose sparse matrix-transpose sparse matrix additions |
Cblaze::TSMatTSMatKronExpr< MT1, MT2 > | Expression object for transpose sparse matrix-transpose sparse matrix Kronecker product |
Cblaze::TSMatTSMatMultExpr< MT1, MT2 > | Expression object for transpose sparse matrix-transpose sparse matrix multiplications |
Cblaze::TSMatTSMatSchurExpr< MT1, MT2 > | Expression object for transpose sparse matrix-transpose sparse matrix Schur product |
Cblaze::TSMatTSMatSubExpr< MT1, MT2 > | Expression object for transpose sparse matrix-transpose sparse matrix subtractions |
Cblaze::TSVecDMatMultExpr< VT, MT > | Expression object for transpose sparse vector-dense matrix multiplications |
Cblaze::TSVecSMatMultExpr< VT, MT > | Expression object for sparse vector-sparse matrix multiplications |
Cblaze::TSVecTDMatMultExpr< VT, MT > | Expression object for transpose sparse vector-transpose dense matrix multiplications |
Cblaze::TSVecTSMatMultExpr< VT, MT > | Expression object for sparse vector-sparse matrix multiplications |
Cblaze::Transformation | Base class for all transform expression templates |
Cblaze::Or | Generic wrapper for the logical OR operator |
Cblaze::OrAssign | Generic wrapper for bitwise OR assignment |
Cblaze::ParallelSection< T > | Section for the debugging of the shared-memory parallelization |
Cblaze::Pow | Generic wrapper for the pow() function |
Cblaze::Pow2 | Generic wrapper for the pow2() function |
Cblaze::Pow3 | Generic wrapper for the pow3() function |
Cblaze::Pow4 | Generic wrapper for the pow4() function |
Cblaze::PtrDelete | Pointer-delete policy class |
Cptrdiff_t | Pointer difference type of the Blaze library |
Cblaze::Qdrt | Generic wrapper for the qdrt() function |
Cblaze::Rand< T, typename > | Default implementation of the Rand class |
Cblaze::Real | Generic wrapper for the real() function |
Cblaze::AlignedAllocator< T >::rebind< U > | Implementation of the AlignedAllocator rebind mechanism |
Cblaze::CompressedMatrix< Type, SO, Tag >::Rebind< NewType > | Rebind mechanism to obtain a CompressedMatrix with different data/element type |
Cblaze::CompressedVector< Type, TF, Tag >::Rebind< NewType > | Rebind mechanism to obtain a CompressedVector with different data/element type |
Cblaze::CustomMatrix< Type, AF, PF, SO, Tag, RT >::Rebind< NewType > | Rebind mechanism to obtain a CustomMatrix with different data/element type |
Cblaze::CustomVector< Type, AF, PF, TF, Tag, RT >::Rebind< NewType > | Rebind mechanism to obtain a CustomVector with different data/element type |
Cblaze::DynamicMatrix< Type, SO, Alloc, Tag >::Rebind< NewType > | Rebind mechanism to obtain a DynamicMatrix with different data/element type |
Cblaze::DynamicVector< Type, TF, Alloc, Tag >::Rebind< NewType > | Rebind mechanism to obtain a DynamicVector with different data/element type |
Cblaze::HybridMatrix< Type, M, N, SO, AF, PF, Tag >::Rebind< NewType > | Rebind mechanism to obtain a HybridMatrix with different data/element type |
Cblaze::HybridVector< Type, N, TF, AF, PF, Tag >::Rebind< NewType > | Rebind mechanism to obtain a HybridVector with different data/element type |
Cblaze::IdentityMatrix< Type, SO, Tag >::Rebind< NewType > | Rebind mechanism to obtain an IdentityMatrix with different data/element type |
Cblaze::InitializerMatrix< Type, Tag >::Rebind< NewType > | Rebind mechanism to obtain a InitializerMatrix with different data/element type |
Cblaze::InitializerVector< Type, TF, Tag >::Rebind< NewType > | Rebind mechanism to obtain a InitializerVector with different data/element type |
Cblaze::NullAllocator< T >::rebind< U > | Implementation of the NullAllocator rebind mechanism |
Cblaze::StaticMatrix< Type, M, N, SO, AF, PF, Tag >::Rebind< NewType > | Rebind mechanism to obtain a StaticMatrix with different data/element type |
Cblaze::StaticVector< Type, N, TF, AF, PF, Tag >::Rebind< NewType > | Rebind mechanism to obtain a StaticVector with different data/element type |
Cblaze::UniformMatrix< Type, SO, Tag >::Rebind< NewType > | Rebind mechanism to obtain a UniformMatrix with different data/element type |
Cblaze::UniformVector< Type, TF, Tag >::Rebind< NewType > | Rebind mechanism to obtain a UniformVector with different data/element type |
Cblaze::ZeroMatrix< Type, SO, Tag >::Rebind< NewType > | Rebind mechanism to obtain a ZeroMatrix with different data/element type |
Cblaze::ZeroVector< Type, TF, Tag >::Rebind< NewType > | Rebind mechanism to obtain a ZeroVector with different data/element type |
Cblaze::RemoveAdaptor< T > | Removal of top level adaptor types |
Cblaze::RemoveAllExtents< T > | Removal of all array extents |
Cblaze::RemoveConst< T > | Removal of const-qualifiers |
Cblaze::RemoveCV< T > | Removal of top level cv-qualifiers |
Cblaze::RemoveCVRef< T > | Removal of top level cv-qualifiers |
Cblaze::RemoveExtent< T > | Removal of the top level array extent |
Cblaze::RemoveLValueReference< T > | Removal of reference modifiers |
Cblaze::RemovePointer< T > | Removal of pointer modifiers |
Cblaze::RemoveReference< T > | Removal of reference modifiers |
Cblaze::RemoveRValueReference< T > | Removal of reference modifiers |
Cblaze::RemoveVolatile< T > | Removal of volatile-qualifiers |
Cblaze::RepeatExprData< Dim, CRAs > | Auxiliary class template for the data members of repeater expression classes |
►Cblaze::RepeatExprData< 1UL, CRAs... > | |
Cblaze::DVecRepeatExpr< VT, TF, CRAs > | Expression object for the dense vector repeat() function |
Cblaze::SVecRepeatExpr< VT, TF, CRAs > | Expression object for the sparse vector repeat() function |
►Cblaze::RepeatExprData< 2UL, CRAs... > | |
Cblaze::DMatRepeatExpr< MT, SO, CRAs > | Expression object for the dense matrix repeat() function |
Cblaze::SMatRepeatExpr< MT, SO, CRAs > | Expression object for the sparse matrix repeat() function |
Cblaze::Reset | Generic wrapper for the reset() function |
Cblaze::CompressedMatrix< Type, SO, Tag >::Resize< NewM, NewN > | Resize mechanism to obtain a CompressedMatrix with different fixed dimensions |
Cblaze::CompressedVector< Type, TF, Tag >::Resize< NewN > | Resize mechanism to obtain a CompressedVector with a different fixed number of elements |
Cblaze::CustomMatrix< Type, AF, PF, SO, Tag, RT >::Resize< NewM, NewN > | Resize mechanism to obtain a CustomMatrix with different fixed dimensions |
Cblaze::CustomVector< Type, AF, PF, TF, Tag, RT >::Resize< NewN > | Resize mechanism to obtain a CustomVector with a different fixed number of elements |
Cblaze::DynamicMatrix< Type, SO, Alloc, Tag >::Resize< NewM, NewN > | Resize mechanism to obtain a DynamicMatrix with different fixed dimensions |
Cblaze::DynamicVector< Type, TF, Alloc, Tag >::Resize< NewN > | Resize mechanism to obtain a DynamicVector with a different fixed number of elements |
Cblaze::HybridMatrix< Type, M, N, SO, AF, PF, Tag >::Resize< NewM, NewN > | Resize mechanism to obtain a HybridMatrix with different fixed dimensions |
Cblaze::HybridVector< Type, N, TF, AF, PF, Tag >::Resize< NewN > | Resize mechanism to obtain a HybridVector with a different fixed number of elements |
Cblaze::IdentityMatrix< Type, SO, Tag >::Resize< NewM, NewN > | Resize mechanism to obtain a IdentityMatrix with different fixed dimensions |
Cblaze::InitializerMatrix< Type, Tag >::Resize< NewM, NewN > | Resize mechanism to obtain a InitializerMatrix with different fixed dimensions |
Cblaze::InitializerVector< Type, TF, Tag >::Resize< NewN > | Resize mechanism to obtain a InitializerVector with a different fixed number of elements |
Cblaze::StaticMatrix< Type, M, N, SO, AF, PF, Tag >::Resize< NewM, NewN > | Resize mechanism to obtain a StaticMatrix with different fixed dimensions |
Cblaze::StaticVector< Type, N, TF, AF, PF, Tag >::Resize< NewN > | Resize mechanism to obtain a StaticVector with a different fixed number of elements |
Cblaze::UniformMatrix< Type, SO, Tag >::Resize< NewM, NewN > | Resize mechanism to obtain a UniformMatrix with different fixed dimensions |
Cblaze::UniformVector< Type, TF, Tag >::Resize< NewN > | Resize mechanism to obtain a UniformVector with a different fixed number of elements |
Cblaze::ZeroMatrix< Type, SO, Tag >::Resize< NewM, NewN > | Resize mechanism to obtain a ZeroMatrix with different fixed dimensions |
Cblaze::ZeroVector< Type, TF, Tag >::Resize< NewN > | Resize mechanism to obtain a ZeroVector with a different fixed number of elements |
Cblaze::RightShiftAssign | Generic wrapper for bitwise right-shift assignment |
Cblaze::Round | Generic wrapper for the round() function |
Cblaze::RowData< CRAs > | Auxiliary class template for the data members of the Row class |
Cblaze::Schur | Generic wrapper for the Schur product |
Cblaze::Serial | Generic wrapper for the Serial() function |
Cblaze::SerialSection< T > | Section to enforce the serial execution of operations |
Cblaze::SharedValue< Type > | Value shared among several positions within a symmetric matrix |
Cblaze::ShiftLI | Generic wrapper for the uniform left-shift operation |
Cblaze::ShiftLV | Generic wrapper for the elementwise left-shift operation |
Cblaze::ShiftRI | Generic wrapper for the uniform right-shift operation |
Cblaze::ShiftRV | Generic wrapper for the elementwise right-shift operation |
Cblaze::Sign | Generic wrapper for the sign() function |
CSIMDcdouble | SIMD type for 64-bit double precision complex values |
CSIMDcfloat | SIMD type for 32-bit single precision complex values |
CSIMDcint16 | SIMD type for 16-bit signed integral complex values |
CSIMDcint32 | SIMD type for 32-bit signed integral complex values |
CSIMDcint64 | SIMD type for 64-bit signed integral complex values |
CSIMDcint8 | SIMD type for 8-bit signed integral complex values |
CSIMDcuint16 | SIMD type for 16-bit unsigned integral complex values |
CSIMDcuint32 | SIMD type for 32-bit unsigned integral complex values |
CSIMDcuint64 | SIMD type for 64-bit unsigned integral complex values |
CSIMDcuint8 | SIMD type for 8-bit unsigned integral complex values |
CSIMDdouble | SIMD type for 64-bit double precision floating point data values |
►CSIMDf32 | |
Cblaze::SIMDf32FmaddExpr< T1, T2, T3 > | Expression object for 32-bit floating point fused multiply-add operations |
Cblaze::SIMDf32FmsubExpr< T1, T2, T3 > | Expression object for 32-bit floating point fused multiply-subtract operations |
Cblaze::SIMDf32MultExpr< T1, T2 > | Expression object for 32-bit floating point multiplication operations |
►CSIMDf64 | |
Cblaze::SIMDf64FmaddExpr< T1, T2, T3 > | Addition operator for fusing a 32-bit floating point multiplication and addition |
Cblaze::SIMDf64FmsubExpr< T1, T2, T3 > | Expression object for 64-bit floating point fused multiply-subtract operations |
Cblaze::SIMDf64MultExpr< T1, T2 > | Expression object for 64-bit floating point multiplication operations |
CSIMDfloat | SIMD type for 32-bit single precision floating point data values |
CSIMDint16 | SIMD type for 16-bit signed integral data values |
CSIMDint32 | SIMD type for 32-bit signed integral data values |
CSIMDint64 | SIMD type for 64-bit integral data values |
CSIMDint8 | SIMD type for 8-bit signed integral data values |
Cblaze::SIMDPack< T > | Base class for all SIMD data types |
►CSIMDTraitBase | |
Cblaze::SIMDTrait< T > | SIMD characteristics of data types |
CSIMDuint16 | SIMD type for 16-bit unsigned integral data values |
CSIMDuint32 | SIMD type for 32-bit unsigned integral data values |
CSIMDuint64 | SIMD type for 64-bit unsigned integral data values |
CSIMDuint8 | SIMD type for 8-bit unsigned integral data values |
Cblaze::Sin | Generic wrapper for the sin() function |
Cblaze::Sinh | Generic wrapper for the sinh() function |
Csize_t | Size type of the Blaze library |
Cblaze::SizeHelper1< typename, size_t, typename > | |
►Cblaze::SizeHelper1< T, N > | |
Cblaze::Size< T, N > | Compile time evaluation of the size of vectors and matrices |
Cblaze::SizeHelper2< typename, size_t, typename > | |
►CSmallArrayData | |
Cblaze::SmallArray< T, N, A > | Implementation of a dynamic array with small array optimization |
Cblaze::SMatFixExpr< MT, SO > | Expression object for fixing the size of a sparse matrix |
Cblaze::SMatReduceExpr< MT, OP, RF > | Base template for row-major sparse matrix partial reduction operations |
Cblaze::SMatVarExpr< MT, RF > | Base template for the row-/column-wise variance computations on row-major sparse matrices |
►Cblaze::SparseElement | Base class for all sparse element types |
Cblaze::HermitianElement< MT > | Representation of two synchronized elements within the sparse Hermitian matrix |
Cblaze::SymmetricElement< MT > | Representation of two synchronized elements within the sparse symmetric matrix |
Cblaze::UniLowerElement< MT > | Representation of an element within a sparse lower unitriangular matrix |
Cblaze::UniUpperElement< MT > | Representation of an element within a sparse upper unitriangular matrix |
Cblaze::ValueIndexPair< Type > | Index-value-pair for sparse vectors and matrices |
Cblaze::SqrAbs | Generic wrapper for the squared abs() function |
Cblaze::Sqrt | Generic wrapper for the sqrt() function |
Cblaze::StrictlyLowerMatrix< MT, SO, DF > | Matrix adapter for strictly lower triangular matrices |
Cblaze::StrictlyUpperMatrix< MT, SO, DF > | Matrix adapter for strictly upper triangular matrices |
Cblaze::Sub | Generic wrapper for the subtraction operator |
Cblaze::SubAssign | Generic wrapper for subtraction assignment |
Cblaze::SubmatrixData< CSAs > | Auxiliary class template for the data members of the Submatrix class |
Cblaze::SubvectorData< CSAs > | Auxiliary class template for the data members of the Subvector class |
Cblaze::SVecFixExpr< VT, TF > | Expression object for fixing the size of a sparse vector |
Cblaze::SymmetricMatrix< MT, SO, DF, SF > | Matrix adapter for symmetric matrices |
►CT | |
►Cblaze::Expression< T > | Base class for all expression templates |
Cblaze::AddExpr< T > | Base class for all addition expression templates |
Cblaze::BinaryMapExpr< T > | Base class for all for-each expression templates |
Cblaze::DeclExpr< T > | Base class for all matrix for-each expression templates |
Cblaze::DivExpr< T > | Base class for all division expression templates |
Cblaze::EvalExpr< T > | Base class for all evaluation expression templates |
Cblaze::ExpandExpr< T > | Base class for all expansion expression templates |
Cblaze::GenExpr< T > | Base class for all for-each expression templates |
Cblaze::MultExpr< T > | Base class for all multiplication expression templates |
Cblaze::NoAliasExpr< T > | Base class for all no-alias expression templates |
Cblaze::NoSIMDExpr< T > | Base class for all no-SIMD expression templates |
Cblaze::ReduceExpr< T > | Base class for all reduction expression templates |
Cblaze::RepeatExpr< T > | Base class for all for-each expression templates |
Cblaze::SerialExpr< T > | Base class for all serial evaluation expression templates |
Cblaze::SolveExpr< T > | Base class for all LSE solver expression templates |
Cblaze::SubExpr< T > | Base class for all subtraction expression templates |
Cblaze::TransExpr< T > | Base class for all transposition expression templates |
Cblaze::UnaryMapExpr< T > | Base class for all for-each expression templates |
Cblaze::View< T > | Base class for all views |
Cblaze::Tan | Generic wrapper for the tan() function |
Cblaze::Tanh | Generic wrapper for the tanh() function |
Cblaze::threadpool::TaskQueue | Task queue for the thread pool |
Cblaze::timing::Timer< TP > | Progress timer for time and performance measurements |
Cblaze::Trans | Generic wrapper for the trans() function |
Cblaze::Trunc | Generic wrapper for the trunc() function |
Cblaze::TypeAt< TL, Index > | Indexing a type list |
Cblaze::TypeList< Ts > | Implementation of a type list |
Cblaze::TypeValueMapping< T > | Conversion from a data type to a serial representation |
Cuint16_t | 16-bit unsigned integer type of the Blaze library |
Cuint32_t | 32-bit unsigned integer type of the Blaze library |
Cuint64_t | 64-bit unsigned integer type of the Blaze library |
Cuint8_t | 8-bit unsigned integer type of the Blaze library |
Cblaze::UnderlyingBuiltin< T > | Evaluation of the underlying builtin element type of a given data type |
Cblaze::UnderlyingElement< T > | Evaluation of the element type of a given data type |
Cblaze::UnderlyingNumeric< T > | Evaluation of the underlying scalar element type of a given data type |
Cblaze::UnderlyingScalar< T > | Evaluation of the underlying scalar element type of a given data type |
Cblaze::UniformIterator< Type, AF > | Implementation of a generic iterator for uniform vectors and matrices |
Cblaze::UniLowerMatrix< MT, SO, DF > | Matrix adapter for lower unitriangular matrices |
Cblaze::DynamicMatrix< Type, SO, Alloc, Tag >::Uninitialized | Definition of the nested auxiliary struct Uninitialized |
Cblaze::DynamicVector< Type, TF, Alloc, Tag >::Uninitialized | Definition of the nested auxiliary struct Uninitialized |
Cblaze::SmallArray< T, N, A >::Uninitialized | Definition of the nested auxiliary struct Uninitialized |
Cblaze::Unique< TL > | Erasing all duplicates from a type list |
Cblaze::UniUpperMatrix< MT, SO, DF > | Matrix adapter for upper unitriangular matrices |
Cblaze::UnsignedValue< T > | Implementation of a wrapper for built-in unsigned integral values |
Cblaze::UpperMatrix< MT, SO, DF > | Matrix adapter for upper triangular matrices |
►Cblaze::Vector< VT, TF > | Base class for N-dimensional vectors |
Cblaze::DenseVector< VT, TF > | Base class for N-dimensional dense vectors |
Cblaze::SparseVector< VT, TF > | Base class for sparse vectors |
►Cblaze::Vector< CompressedVector< Type, TF, Tag >, TF > | |
►Cblaze::SparseVector< CompressedVector< Type, TF, Tag >, TF > | |
Cblaze::CompressedVector< Type, TF, Tag > | Efficient implementation of an arbitrary sized sparse vector |
►Cblaze::Vector< CustomVector< Type, AF, PF, TF, Tag, RT >, TF > | |
►Cblaze::DenseVector< CustomVector< Type, AF, PF, TF, Tag, RT >, TF > | |
Cblaze::CustomVector< Type, AF, PF, TF, Tag, RT > | Efficient implementation of a customizable vector |
►Cblaze::Vector< DMatDVecMultExpr< MT, VT >, TF > | |
►Cblaze::DenseVector< DMatDVecMultExpr< MT, VT >, false > | |
►Cblaze::Expression< DenseVector< DMatDVecMultExpr< MT, VT >, false > > | |
►Cblaze::MultExpr< DenseVector< DMatDVecMultExpr< MT, VT >, false > > | |
►Cblaze::MatVecMultExpr< DenseVector< DMatDVecMultExpr< MT, VT >, false > > | |
Cblaze::DMatDVecMultExpr< MT, VT > | Expression object for dense matrix-dense vector multiplications |
►Cblaze::Vector< DMatDVecSolveExpr< MT, VT, TF >, TF > | |
►Cblaze::DenseVector< DMatDVecSolveExpr< MT, VT, TF >, TF > | |
►Cblaze::Expression< DenseVector< DMatDVecSolveExpr< MT, VT, TF >, TF > > | |
►Cblaze::SolveExpr< DenseVector< DMatDVecSolveExpr< MT, VT, TF >, TF > > | |
►Cblaze::MatVecSolveExpr< DenseVector< DMatDVecSolveExpr< MT, VT, TF >, TF > > | |
Cblaze::DMatDVecSolveExpr< MT, VT, TF > | Expression object for dense matrix-dense vector solvers |
►Cblaze::Vector< DMatEigenExpr< MT, SO >, TF > | |
►Cblaze::DenseVector< DMatEigenExpr< MT, SO >, false > | |
►Cblaze::Expression< DenseVector< DMatEigenExpr< MT, SO >, false > > | |
►Cblaze::EigenExpr< DenseVector< DMatEigenExpr< MT, SO >, false > > | |
Cblaze::DMatEigenExpr< MT, SO > | Expression object for dense matrix eigenvalue solvers |
►Cblaze::Vector< DMatReduceExpr< MT, OP, columnwise >, TF > | |
►Cblaze::DenseVector< DMatReduceExpr< MT, OP, columnwise >, true > | |
►Cblaze::Expression< DenseVector< DMatReduceExpr< MT, OP, columnwise >, true > > | |
►Cblaze::ReduceExpr< DenseVector< DMatReduceExpr< MT, OP, columnwise >, true > > | |
►Cblaze::MatReduceExpr< DenseVector< DMatReduceExpr< MT, OP, columnwise >, true >, columnwise > | |
Cblaze::DMatReduceExpr< MT, OP, columnwise > | Expression object for column-wise row-major dense matrix reduction operations |
►Cblaze::Vector< DMatReduceExpr< MT, OP, rowwise >, TF > | |
►Cblaze::DenseVector< DMatReduceExpr< MT, OP, rowwise >, false > | |
►Cblaze::Expression< DenseVector< DMatReduceExpr< MT, OP, rowwise >, false > > | |
►Cblaze::ReduceExpr< DenseVector< DMatReduceExpr< MT, OP, rowwise >, false > > | |
►Cblaze::MatReduceExpr< DenseVector< DMatReduceExpr< MT, OP, rowwise >, false >, rowwise > | |
Cblaze::DMatReduceExpr< MT, OP, rowwise > | Expression object for row-wise row-major dense matrix reduction operations |
►Cblaze::Vector< DMatSVDExpr< MT, SO >, TF > | |
►Cblaze::DenseVector< DMatSVDExpr< MT, SO >, false > | |
►Cblaze::Expression< DenseVector< DMatSVDExpr< MT, SO >, false > > | |
►Cblaze::SVDExpr< DenseVector< DMatSVDExpr< MT, SO >, false > > | |
Cblaze::DMatSVDExpr< MT, SO > | Expression object for dense matrix singular value solvers |
►Cblaze::Vector< DMatSVecMultExpr< MT, VT >, TF > | |
►Cblaze::DenseVector< DMatSVecMultExpr< MT, VT >, false > | |
►Cblaze::Expression< DenseVector< DMatSVecMultExpr< MT, VT >, false > > | |
►Cblaze::MultExpr< DenseVector< DMatSVecMultExpr< MT, VT >, false > > | |
►Cblaze::MatVecMultExpr< DenseVector< DMatSVecMultExpr< MT, VT >, false > > | |
Cblaze::DMatSVecMultExpr< MT, VT > | Expression object for dense matrix-sparse vector multiplications |
►Cblaze::Vector< DVecDVecAddExpr< VT1, VT2, TF >, TF > | |
►Cblaze::DenseVector< DVecDVecAddExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecDVecAddExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::AddExpr< DenseVector< DVecDVecAddExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecAddExpr< DenseVector< DVecDVecAddExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecDVecAddExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector additions |
►Cblaze::Vector< DVecDVecCrossExpr< VT1, VT2, TF >, TF > | |
►Cblaze::DenseVector< DVecDVecCrossExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecDVecCrossExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::CrossExpr< DenseVector< DVecDVecCrossExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecDVecCrossExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector cross products |
►Cblaze::Vector< DVecDVecDivExpr< VT1, VT2, TF >, TF > | |
►Cblaze::DenseVector< DVecDVecDivExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecDVecDivExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::DivExpr< DenseVector< DVecDVecDivExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecDivExpr< DenseVector< DVecDVecDivExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecDVecDivExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector divisions |
►Cblaze::Vector< DVecDVecKronExpr< VT1, VT2, TF >, TF > | |
►Cblaze::DenseVector< DVecDVecKronExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecDVecKronExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::KronExpr< DenseVector< DVecDVecKronExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecKronExpr< DenseVector< DVecDVecKronExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecDVecKronExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector Kronecker product |
►Cblaze::Vector< DVecDVecMapExpr< VT1, VT2, OP, TF >, TF > | |
►Cblaze::DenseVector< DVecDVecMapExpr< VT1, VT2, OP, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecDVecMapExpr< VT1, VT2, OP, TF >, TF > > | |
►Cblaze::BinaryMapExpr< DenseVector< DVecDVecMapExpr< VT1, VT2, OP, TF >, TF > > | |
►Cblaze::VecVecMapExpr< DenseVector< DVecDVecMapExpr< VT1, VT2, OP, TF >, TF > > | |
Cblaze::DVecDVecMapExpr< VT1, VT2, OP, TF > | Expression object for the dense vector-dense vector map() function |
►Cblaze::Vector< DVecDVecMultExpr< VT1, VT2, TF >, TF > | |
►Cblaze::DenseVector< DVecDVecMultExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecDVecMultExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::MultExpr< DenseVector< DVecDVecMultExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecMultExpr< DenseVector< DVecDVecMultExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecDVecMultExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector multiplications |
►Cblaze::Vector< DVecDVecSubExpr< VT1, VT2, TF >, TF > | |
►Cblaze::DenseVector< DVecDVecSubExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecDVecSubExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::SubExpr< DenseVector< DVecDVecSubExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecSubExpr< DenseVector< DVecDVecSubExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecDVecSubExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector subtractions |
►Cblaze::Vector< DVecEvalExpr< VT, TF >, TF > | |
►Cblaze::DenseVector< DVecEvalExpr< VT, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecEvalExpr< VT, TF >, TF > > | |
►Cblaze::EvalExpr< DenseVector< DVecEvalExpr< VT, TF >, TF > > | |
►Cblaze::VecEvalExpr< DenseVector< DVecEvalExpr< VT, TF >, TF > > | |
Cblaze::DVecEvalExpr< VT, TF > | Expression object for the forced evaluation of dense vectors |
►Cblaze::Vector< DVecGenExpr< VT, OP, TF >, TF > | |
►Cblaze::DenseVector< DVecGenExpr< VT, OP, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecGenExpr< VT, OP, TF >, TF > > | |
►Cblaze::GenExpr< DenseVector< DVecGenExpr< VT, OP, TF >, TF > > | |
►Cblaze::VecGenExpr< DenseVector< DVecGenExpr< VT, OP, TF >, TF > > | |
Cblaze::DVecGenExpr< VT, OP, TF > | Expression object for the dense vector generate() function |
►Cblaze::Vector< DVecMapExpr< VT, OP, TF >, TF > | |
►Cblaze::DenseVector< DVecMapExpr< VT, OP, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecMapExpr< VT, OP, TF >, TF > > | |
►Cblaze::UnaryMapExpr< DenseVector< DVecMapExpr< VT, OP, TF >, TF > > | |
►Cblaze::VecMapExpr< DenseVector< DVecMapExpr< VT, OP, TF >, TF > > | |
Cblaze::DVecMapExpr< VT, OP, TF > | Expression object for the dense vector map() function |
►Cblaze::Vector< DVecNoAliasExpr< VT, TF >, TF > | |
►Cblaze::DenseVector< DVecNoAliasExpr< VT, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecNoAliasExpr< VT, TF >, TF > > | |
►Cblaze::NoAliasExpr< DenseVector< DVecNoAliasExpr< VT, TF >, TF > > | |
►Cblaze::VecNoAliasExpr< DenseVector< DVecNoAliasExpr< VT, TF >, TF > > | |
Cblaze::DVecNoAliasExpr< VT, TF > | Expression object for the non-aliased evaluation of dense vectors |
►Cblaze::Vector< DVecNoSIMDExpr< VT, TF >, TF > | |
►Cblaze::DenseVector< DVecNoSIMDExpr< VT, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecNoSIMDExpr< VT, TF >, TF > > | |
►Cblaze::NoSIMDExpr< DenseVector< DVecNoSIMDExpr< VT, TF >, TF > > | |
►Cblaze::VecNoSIMDExpr< DenseVector< DVecNoSIMDExpr< VT, TF >, TF > > | |
Cblaze::DVecNoSIMDExpr< VT, TF > | Expression object for the non-SIMD evaluation of dense vectors |
►Cblaze::Vector< DVecRepeatExpr< VT, TF, CRAs... >, TF > | |
►Cblaze::DenseVector< DVecRepeatExpr< VT, TF, CRAs... >, TF > | |
►Cblaze::Expression< DenseVector< DVecRepeatExpr< VT, TF, CRAs... >, TF > > | |
►Cblaze::RepeatExpr< DenseVector< DVecRepeatExpr< VT, TF, CRAs... >, TF > > | |
►Cblaze::VecRepeatExpr< DenseVector< DVecRepeatExpr< VT, TF, CRAs... >, TF >, CRAs... > | |
Cblaze::DVecRepeatExpr< VT, TF, CRAs > | Expression object for the dense vector repeat() function |
►Cblaze::Vector< DVecScalarDivExpr< VT, ST, TF >, TF > | |
►Cblaze::DenseVector< DVecScalarDivExpr< VT, ST, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecScalarDivExpr< VT, ST, TF >, TF > > | |
►Cblaze::DivExpr< DenseVector< DVecScalarDivExpr< VT, ST, TF >, TF > > | |
►Cblaze::VecScalarDivExpr< DenseVector< DVecScalarDivExpr< VT, ST, TF >, TF > > | |
Cblaze::DVecScalarDivExpr< VT, ST, TF > | Expression object for divisions of a dense vector by a scalar |
►Cblaze::Vector< DVecScalarMultExpr< VT, ST, TF >, TF > | |
►Cblaze::DenseVector< DVecScalarMultExpr< VT, ST, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecScalarMultExpr< VT, ST, TF >, TF > > | |
►Cblaze::MultExpr< DenseVector< DVecScalarMultExpr< VT, ST, TF >, TF > > | |
►Cblaze::VecScalarMultExpr< DenseVector< DVecScalarMultExpr< VT, ST, TF >, TF > > | |
Cblaze::DVecScalarMultExpr< VT, ST, TF > | Expression object for dense vector-scalar multiplications |
►Cblaze::Vector< DVecSerialExpr< VT, TF >, TF > | |
►Cblaze::DenseVector< DVecSerialExpr< VT, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecSerialExpr< VT, TF >, TF > > | |
►Cblaze::SerialExpr< DenseVector< DVecSerialExpr< VT, TF >, TF > > | |
►Cblaze::VecSerialExpr< DenseVector< DVecSerialExpr< VT, TF >, TF > > | |
Cblaze::DVecSerialExpr< VT, TF > | Expression object for the forced serial evaluation of dense vectors |
►Cblaze::Vector< DVecSVecAddExpr< VT1, VT2, TF >, TF > | |
►Cblaze::DenseVector< DVecSVecAddExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecSVecAddExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::AddExpr< DenseVector< DVecSVecAddExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecAddExpr< DenseVector< DVecSVecAddExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecSVecAddExpr< VT1, VT2, TF > | Expression object for dense vector-sparse vector additions |
►Cblaze::Vector< DVecSVecCrossExpr< VT1, VT2, TF >, TF > | |
►Cblaze::DenseVector< DVecSVecCrossExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecSVecCrossExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::CrossExpr< DenseVector< DVecSVecCrossExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecSVecCrossExpr< VT1, VT2, TF > | Expression object for dense vector-sparse vector cross products |
►Cblaze::Vector< DVecSVecKronExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< DVecSVecKronExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< DVecSVecKronExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::KronExpr< SparseVector< DVecSVecKronExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecKronExpr< SparseVector< DVecSVecKronExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecSVecKronExpr< VT1, VT2, TF > | Expression object for dense vector-sparse vector Kronecker product |
►Cblaze::Vector< DVecSVecMultExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< DVecSVecMultExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< DVecSVecMultExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::MultExpr< SparseVector< DVecSVecMultExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecMultExpr< SparseVector< DVecSVecMultExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecSVecMultExpr< VT1, VT2, TF > | Expression object for dense vector-sparse vector multiplications |
►Cblaze::Vector< DVecSVecSubExpr< VT1, VT2, TF >, TF > | |
►Cblaze::DenseVector< DVecSVecSubExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecSVecSubExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::SubExpr< DenseVector< DVecSVecSubExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecSubExpr< DenseVector< DVecSVecSubExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecSVecSubExpr< VT1, VT2, TF > | Expression object for dense vector-sparse vector subtractions |
►Cblaze::Vector< DVecTransExpr< VT, TF >, TF > | |
►Cblaze::DenseVector< DVecTransExpr< VT, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecTransExpr< VT, TF >, TF > > | |
►Cblaze::TransExpr< DenseVector< DVecTransExpr< VT, TF >, TF > > | |
►Cblaze::VecTransExpr< DenseVector< DVecTransExpr< VT, TF >, TF > > | |
Cblaze::DVecTransExpr< VT, TF > | Expression object for dense vector transpositions |
►Cblaze::Vector< DVecTransposer< VT, TF >, TF > | |
►Cblaze::DenseVector< DVecTransposer< VT, TF >, TF > | |
Cblaze::DVecTransposer< VT, TF > | Expression object for the transposition of a dense vector |
►Cblaze::Vector< DynamicVector< Type, TF, Alloc, Tag >, TF > | |
►Cblaze::DenseVector< DynamicVector< Type, TF, Alloc, Tag >, TF > | |
Cblaze::DynamicVector< Type, TF, Alloc, Tag > | Efficient implementation of an arbitrary sized vector |
►Cblaze::Vector< HybridVector< Type, N, TF, AF, PF, Tag >, TF > | |
►Cblaze::DenseVector< HybridVector< Type, N, TF, AF, PF, Tag >, TF > | |
Cblaze::HybridVector< Type, N, TF, AF, PF, Tag > | Efficient implementation of a dynamically sized vector with static memory |
►Cblaze::Vector< InitializerVector< Type, TF, Tag >, TF > | |
►Cblaze::DenseVector< InitializerVector< Type, TF, Tag >, TF > | |
Cblaze::InitializerVector< Type, TF, Tag > | Dense vector representation of an initializer list |
►Cblaze::Vector< PT, TF > | |
►Cblaze::DenseVector< PT, IsRowVector_v< VT > > | |
Cblaze::DenseVectorProxy< PT, VT > | Proxy backend for dense vector types |
►Cblaze::SparseVector< PT, IsRowVector_v< VT > > | |
Cblaze::SparseVectorProxy< PT, VT > | Proxy backend for sparse vector types |
►Cblaze::Vector< SMatDVecMultExpr< MT, VT >, TF > | |
►Cblaze::DenseVector< SMatDVecMultExpr< MT, VT >, false > | |
►Cblaze::Expression< DenseVector< SMatDVecMultExpr< MT, VT >, false > > | |
►Cblaze::MultExpr< DenseVector< SMatDVecMultExpr< MT, VT >, false > > | |
►Cblaze::MatVecMultExpr< DenseVector< SMatDVecMultExpr< MT, VT >, false > > | |
Cblaze::SMatDVecMultExpr< MT, VT > | Expression object for sparse matrix-dense vector multiplications |
►Cblaze::Vector< SMatReduceExpr< MT, OP, columnwise >, TF > | |
►Cblaze::DenseVector< SMatReduceExpr< MT, OP, columnwise >, true > | |
►Cblaze::Expression< DenseVector< SMatReduceExpr< MT, OP, columnwise >, true > > | |
►Cblaze::ReduceExpr< DenseVector< SMatReduceExpr< MT, OP, columnwise >, true > > | |
►Cblaze::MatReduceExpr< DenseVector< SMatReduceExpr< MT, OP, columnwise >, true >, columnwise > | |
Cblaze::SMatReduceExpr< MT, OP, columnwise > | Expression object for column-wise row-major sparse matrix reduction operations |
►Cblaze::Vector< SMatReduceExpr< MT, OP, rowwise >, TF > | |
►Cblaze::DenseVector< SMatReduceExpr< MT, OP, rowwise >, false > | |
►Cblaze::Expression< DenseVector< SMatReduceExpr< MT, OP, rowwise >, false > > | |
►Cblaze::ReduceExpr< DenseVector< SMatReduceExpr< MT, OP, rowwise >, false > > | |
►Cblaze::MatReduceExpr< DenseVector< SMatReduceExpr< MT, OP, rowwise >, false >, rowwise > | |
Cblaze::SMatReduceExpr< MT, OP, rowwise > | Expression object for row-wise row-major sparse matrix reduction operations |
►Cblaze::Vector< SMatSVecMultExpr< MT, VT >, TF > | |
►Cblaze::SparseVector< SMatSVecMultExpr< MT, VT >, false > | |
►Cblaze::Expression< SparseVector< SMatSVecMultExpr< MT, VT >, false > > | |
►Cblaze::MultExpr< SparseVector< SMatSVecMultExpr< MT, VT >, false > > | |
►Cblaze::MatVecMultExpr< SparseVector< SMatSVecMultExpr< MT, VT >, false > > | |
Cblaze::SMatSVecMultExpr< MT, VT > | Expression object for sparse matrix-sparse vector multiplications |
►Cblaze::Vector< SMatVarExpr< MT, columnwise >, TF > | |
►Cblaze::DenseVector< SMatVarExpr< MT, columnwise >, true > | |
►Cblaze::Expression< DenseVector< SMatVarExpr< MT, columnwise >, true > > | |
►Cblaze::ReduceExpr< DenseVector< SMatVarExpr< MT, columnwise >, true > > | |
►Cblaze::MatReduceExpr< DenseVector< SMatVarExpr< MT, columnwise >, true >, columnwise > | |
Cblaze::SMatVarExpr< MT, columnwise > | Expression object for the column-wise variance function on row-major sparse matrices |
►Cblaze::Vector< SMatVarExpr< MT, rowwise >, TF > | |
►Cblaze::DenseVector< SMatVarExpr< MT, rowwise >, false > | |
►Cblaze::Expression< DenseVector< SMatVarExpr< MT, rowwise >, false > > | |
►Cblaze::ReduceExpr< DenseVector< SMatVarExpr< MT, rowwise >, false > > | |
►Cblaze::MatReduceExpr< DenseVector< SMatVarExpr< MT, rowwise >, false >, rowwise > | |
Cblaze::SMatVarExpr< MT, rowwise > | Expression object for the row-wise variance function on row-major sparse matrices |
►Cblaze::Vector< StaticVector< Type, N, TF, AF, PF, Tag >, TF > | |
►Cblaze::DenseVector< StaticVector< Type, N, TF, AF, PF, Tag >, TF > | |
Cblaze::StaticVector< Type, N, TF, AF, PF, Tag > | Efficient implementation of a fixed-sized vector |
►Cblaze::Vector< SVecDVecCrossExpr< VT1, VT2, TF >, TF > | |
►Cblaze::DenseVector< SVecDVecCrossExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< SVecDVecCrossExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::CrossExpr< DenseVector< SVecDVecCrossExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecDVecCrossExpr< VT1, VT2, TF > | Expression object for sparse vector-dense vector cross products |
►Cblaze::Vector< SVecDVecDivExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< SVecDVecDivExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecDVecDivExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::DivExpr< SparseVector< SVecDVecDivExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecDivExpr< SparseVector< SVecDVecDivExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecDVecDivExpr< VT1, VT2, TF > | Expression object for sparse vector-dense vector divisions |
►Cblaze::Vector< SVecDVecKronExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< SVecDVecKronExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecDVecKronExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::KronExpr< SparseVector< SVecDVecKronExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecKronExpr< SparseVector< SVecDVecKronExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecDVecKronExpr< VT1, VT2, TF > | Expression object for sparse vector-dense vector Kronecker products |
►Cblaze::Vector< SVecDVecMultExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< SVecDVecMultExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecDVecMultExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::MultExpr< SparseVector< SVecDVecMultExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecMultExpr< SparseVector< SVecDVecMultExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecDVecMultExpr< VT1, VT2, TF > | Expression object for sparse vector-dense vector multiplications |
►Cblaze::Vector< SVecDVecSubExpr< VT1, VT2, TF >, TF > | |
►Cblaze::DenseVector< SVecDVecSubExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< SVecDVecSubExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::SubExpr< DenseVector< SVecDVecSubExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecSubExpr< DenseVector< SVecDVecSubExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecDVecSubExpr< VT1, VT2, TF > | Expression object for sparse vector-dense vector subtractions |
►Cblaze::Vector< SVecEvalExpr< VT, TF >, TF > | |
►Cblaze::SparseVector< SVecEvalExpr< VT, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecEvalExpr< VT, TF >, TF > > | |
►Cblaze::EvalExpr< SparseVector< SVecEvalExpr< VT, TF >, TF > > | |
►Cblaze::VecEvalExpr< SparseVector< SVecEvalExpr< VT, TF >, TF > > | |
Cblaze::SVecEvalExpr< VT, TF > | Expression object for the forced evaluation of sparse vectors |
►Cblaze::Vector< SVecMapExpr< VT, OP, TF >, TF > | |
►Cblaze::SparseVector< SVecMapExpr< VT, OP, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecMapExpr< VT, OP, TF >, TF > > | |
►Cblaze::UnaryMapExpr< SparseVector< SVecMapExpr< VT, OP, TF >, TF > > | |
►Cblaze::VecMapExpr< SparseVector< SVecMapExpr< VT, OP, TF >, TF > > | |
Cblaze::SVecMapExpr< VT, OP, TF > | Expression object for the sparse vector map() function |
►Cblaze::Vector< SVecNoAliasExpr< VT, TF >, TF > | |
►Cblaze::SparseVector< SVecNoAliasExpr< VT, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecNoAliasExpr< VT, TF >, TF > > | |
►Cblaze::NoAliasExpr< SparseVector< SVecNoAliasExpr< VT, TF >, TF > > | |
►Cblaze::VecNoAliasExpr< SparseVector< SVecNoAliasExpr< VT, TF >, TF > > | |
Cblaze::SVecNoAliasExpr< VT, TF > | Expression object for the non-aliased evaluation of sparse vectors |
►Cblaze::Vector< SVecRepeatExpr< VT, TF, CRAs... >, TF > | |
►Cblaze::SparseVector< SVecRepeatExpr< VT, TF, CRAs... >, TF > | |
►Cblaze::Expression< SparseVector< SVecRepeatExpr< VT, TF, CRAs... >, TF > > | |
►Cblaze::RepeatExpr< SparseVector< SVecRepeatExpr< VT, TF, CRAs... >, TF > > | |
►Cblaze::VecRepeatExpr< SparseVector< SVecRepeatExpr< VT, TF, CRAs... >, TF >, CRAs... > | |
Cblaze::SVecRepeatExpr< VT, TF, CRAs > | Expression object for the sparse vector repeat() function |
►Cblaze::Vector< SVecScalarDivExpr< VT, ST, TF >, TF > | |
►Cblaze::SparseVector< SVecScalarDivExpr< VT, ST, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecScalarDivExpr< VT, ST, TF >, TF > > | |
►Cblaze::DivExpr< SparseVector< SVecScalarDivExpr< VT, ST, TF >, TF > > | |
►Cblaze::VecScalarDivExpr< SparseVector< SVecScalarDivExpr< VT, ST, TF >, TF > > | |
Cblaze::SVecScalarDivExpr< VT, ST, TF > | Expression object for divisions of a sparse vector by a scalar |
►Cblaze::Vector< SVecScalarMultExpr< VT, ST, TF >, TF > | |
►Cblaze::SparseVector< SVecScalarMultExpr< VT, ST, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecScalarMultExpr< VT, ST, TF >, TF > > | |
►Cblaze::MultExpr< SparseVector< SVecScalarMultExpr< VT, ST, TF >, TF > > | |
►Cblaze::VecScalarMultExpr< SparseVector< SVecScalarMultExpr< VT, ST, TF >, TF > > | |
Cblaze::SVecScalarMultExpr< VT, ST, TF > | Expression object for sparse vector-scalar multiplications |
►Cblaze::Vector< SVecSerialExpr< VT, TF >, TF > | |
►Cblaze::SparseVector< SVecSerialExpr< VT, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecSerialExpr< VT, TF >, TF > > | |
►Cblaze::SerialExpr< SparseVector< SVecSerialExpr< VT, TF >, TF > > | |
►Cblaze::VecSerialExpr< SparseVector< SVecSerialExpr< VT, TF >, TF > > | |
Cblaze::SVecSerialExpr< VT, TF > | Expression object for the forced serial evaluation of sparse vectors |
►Cblaze::Vector< SVecSVecAddExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< SVecSVecAddExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecSVecAddExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::AddExpr< SparseVector< SVecSVecAddExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecAddExpr< SparseVector< SVecSVecAddExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecSVecAddExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector additions |
►Cblaze::Vector< SVecSVecCrossExpr< VT1, VT2, TF >, TF > | |
►Cblaze::DenseVector< SVecSVecCrossExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< SVecSVecCrossExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::CrossExpr< DenseVector< SVecSVecCrossExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecSVecCrossExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector cross products |
►Cblaze::Vector< SVecSVecKronExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< SVecSVecKronExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecSVecKronExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::KronExpr< SparseVector< SVecSVecKronExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecKronExpr< SparseVector< SVecSVecKronExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecSVecKronExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector Kronecker products |
►Cblaze::Vector< SVecSVecMultExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< SVecSVecMultExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecSVecMultExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::MultExpr< SparseVector< SVecSVecMultExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecMultExpr< SparseVector< SVecSVecMultExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecSVecMultExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector multiplications |
►Cblaze::Vector< SVecSVecSubExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< SVecSVecSubExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecSVecSubExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::SubExpr< SparseVector< SVecSVecSubExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecSubExpr< SparseVector< SVecSVecSubExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecSVecSubExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector subtractions |
►Cblaze::Vector< SVecTransExpr< VT, TF >, TF > | |
►Cblaze::SparseVector< SVecTransExpr< VT, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecTransExpr< VT, TF >, TF > > | |
►Cblaze::TransExpr< SparseVector< SVecTransExpr< VT, TF >, TF > > | |
►Cblaze::VecTransExpr< SparseVector< SVecTransExpr< VT, TF >, TF > > | |
Cblaze::SVecTransExpr< VT, TF > | Expression object for sparse vector transpositions |
►Cblaze::Vector< SVecTransposer< VT, TF >, TF > | |
►Cblaze::SparseVector< SVecTransposer< VT, TF >, TF > | |
Cblaze::SVecTransposer< VT, TF > | Expression object for the transposition of a sparse vector |
►Cblaze::Vector< TDMatDVecMultExpr< MT, VT >, TF > | |
►Cblaze::DenseVector< TDMatDVecMultExpr< MT, VT >, false > | |
►Cblaze::Expression< DenseVector< TDMatDVecMultExpr< MT, VT >, false > > | |
►Cblaze::MultExpr< DenseVector< TDMatDVecMultExpr< MT, VT >, false > > | |
►Cblaze::MatVecMultExpr< DenseVector< TDMatDVecMultExpr< MT, VT >, false > > | |
Cblaze::TDMatDVecMultExpr< MT, VT > | Expression object for transpose dense matrix-dense vector multiplications |
►Cblaze::Vector< TDMatSVecMultExpr< MT, VT >, TF > | |
►Cblaze::DenseVector< TDMatSVecMultExpr< MT, VT >, false > | |
►Cblaze::Expression< DenseVector< TDMatSVecMultExpr< MT, VT >, false > > | |
►Cblaze::MultExpr< DenseVector< TDMatSVecMultExpr< MT, VT >, false > > | |
►Cblaze::MatVecMultExpr< DenseVector< TDMatSVecMultExpr< MT, VT >, false > > | |
Cblaze::TDMatSVecMultExpr< MT, VT > | Expression object for transpose dense matrix-sparse vector multiplications |
►Cblaze::Vector< TDVecDMatMultExpr< VT, MT >, TF > | |
►Cblaze::DenseVector< TDVecDMatMultExpr< VT, MT >, true > | |
►Cblaze::Expression< DenseVector< TDVecDMatMultExpr< VT, MT >, true > > | |
►Cblaze::MultExpr< DenseVector< TDVecDMatMultExpr< VT, MT >, true > > | |
►Cblaze::TVecMatMultExpr< DenseVector< TDVecDMatMultExpr< VT, MT >, true > > | |
Cblaze::TDVecDMatMultExpr< VT, MT > | Expression object for transpose dense vector-dense matrix multiplications |
►Cblaze::Vector< TDVecSMatMultExpr< VT, MT >, TF > | |
►Cblaze::DenseVector< TDVecSMatMultExpr< VT, MT >, true > | |
►Cblaze::Expression< DenseVector< TDVecSMatMultExpr< VT, MT >, true > > | |
►Cblaze::MultExpr< DenseVector< TDVecSMatMultExpr< VT, MT >, true > > | |
►Cblaze::TVecMatMultExpr< DenseVector< TDVecSMatMultExpr< VT, MT >, true > > | |
Cblaze::TDVecSMatMultExpr< VT, MT > | Expression object for transpose dense vector-sparse matrix multiplications |
►Cblaze::Vector< TDVecTDMatMultExpr< VT, MT >, TF > | |
►Cblaze::DenseVector< TDVecTDMatMultExpr< VT, MT >, true > | |
►Cblaze::Expression< DenseVector< TDVecTDMatMultExpr< VT, MT >, true > > | |
►Cblaze::MultExpr< DenseVector< TDVecTDMatMultExpr< VT, MT >, true > > | |
►Cblaze::TVecMatMultExpr< DenseVector< TDVecTDMatMultExpr< VT, MT >, true > > | |
Cblaze::TDVecTDMatMultExpr< VT, MT > | Expression object for transpose dense vector-transpose dense matrix multiplications |
►Cblaze::Vector< TDVecTSMatMultExpr< VT, MT >, TF > | |
►Cblaze::DenseVector< TDVecTSMatMultExpr< VT, MT >, true > | |
►Cblaze::Expression< DenseVector< TDVecTSMatMultExpr< VT, MT >, true > > | |
►Cblaze::MultExpr< DenseVector< TDVecTSMatMultExpr< VT, MT >, true > > | |
►Cblaze::TVecMatMultExpr< DenseVector< TDVecTSMatMultExpr< VT, MT >, true > > | |
Cblaze::TDVecTSMatMultExpr< VT, MT > | Expression object for transpose dense vector-transpose sparse matrix multiplications |
►Cblaze::Vector< TSMatDVecMultExpr< MT, VT >, TF > | |
►Cblaze::DenseVector< TSMatDVecMultExpr< MT, VT >, false > | |
►Cblaze::Expression< DenseVector< TSMatDVecMultExpr< MT, VT >, false > > | |
►Cblaze::MultExpr< DenseVector< TSMatDVecMultExpr< MT, VT >, false > > | |
►Cblaze::MatVecMultExpr< DenseVector< TSMatDVecMultExpr< MT, VT >, false > > | |
Cblaze::TSMatDVecMultExpr< MT, VT > | Expression object for transpose sparse matrix-dense vector multiplications |
►Cblaze::Vector< TSMatSVecMultExpr< MT, VT >, TF > | |
►Cblaze::SparseVector< TSMatSVecMultExpr< MT, VT >, false > | |
►Cblaze::Expression< SparseVector< TSMatSVecMultExpr< MT, VT >, false > > | |
►Cblaze::MultExpr< SparseVector< TSMatSVecMultExpr< MT, VT >, false > > | |
►Cblaze::MatVecMultExpr< SparseVector< TSMatSVecMultExpr< MT, VT >, false > > | |
Cblaze::TSMatSVecMultExpr< MT, VT > | Expression object for sparse matrix-sparse vector multiplications |
►Cblaze::Vector< TSVecDMatMultExpr< VT, MT >, TF > | |
►Cblaze::DenseVector< TSVecDMatMultExpr< VT, MT >, true > | |
►Cblaze::Expression< DenseVector< TSVecDMatMultExpr< VT, MT >, true > > | |
►Cblaze::MultExpr< DenseVector< TSVecDMatMultExpr< VT, MT >, true > > | |
►Cblaze::TVecMatMultExpr< DenseVector< TSVecDMatMultExpr< VT, MT >, true > > | |
Cblaze::TSVecDMatMultExpr< VT, MT > | Expression object for transpose sparse vector-dense matrix multiplications |
►Cblaze::Vector< TSVecSMatMultExpr< VT, MT >, TF > | |
►Cblaze::SparseVector< TSVecSMatMultExpr< VT, MT >, true > | |
►Cblaze::Expression< SparseVector< TSVecSMatMultExpr< VT, MT >, true > > | |
►Cblaze::MultExpr< SparseVector< TSVecSMatMultExpr< VT, MT >, true > > | |
►Cblaze::TVecMatMultExpr< SparseVector< TSVecSMatMultExpr< VT, MT >, true > > | |
Cblaze::TSVecSMatMultExpr< VT, MT > | Expression object for sparse vector-sparse matrix multiplications |
►Cblaze::Vector< TSVecTDMatMultExpr< VT, MT >, TF > | |
►Cblaze::DenseVector< TSVecTDMatMultExpr< VT, MT >, true > | |
►Cblaze::Expression< DenseVector< TSVecTDMatMultExpr< VT, MT >, true > > | |
►Cblaze::MultExpr< DenseVector< TSVecTDMatMultExpr< VT, MT >, true > > | |
►Cblaze::TVecMatMultExpr< DenseVector< TSVecTDMatMultExpr< VT, MT >, true > > | |
Cblaze::TSVecTDMatMultExpr< VT, MT > | Expression object for transpose sparse vector-transpose dense matrix multiplications |
►Cblaze::Vector< TSVecTSMatMultExpr< VT, MT >, TF > | |
►Cblaze::SparseVector< TSVecTSMatMultExpr< VT, MT >, true > | |
►Cblaze::Expression< SparseVector< TSVecTSMatMultExpr< VT, MT >, true > > | |
►Cblaze::MultExpr< SparseVector< TSVecTSMatMultExpr< VT, MT >, true > > | |
►Cblaze::TVecMatMultExpr< SparseVector< TSVecTSMatMultExpr< VT, MT >, true > > | |
Cblaze::TSVecTSMatMultExpr< VT, MT > | Expression object for sparse vector-sparse matrix multiplications |
►Cblaze::Vector< UniformVector< Type, TF, Tag >, TF > | |
►Cblaze::DenseVector< UniformVector< Type, TF, Tag >, TF > | |
►Cblaze::Expression< DenseVector< UniformVector< Type, TF, Tag >, TF > > | |
Cblaze::UniformVector< Type, TF, Tag > | Efficient implementation of a uniform vector |
►Cblaze::Vector< ZeroVector< Type, TF, Tag >, TF > | |
►Cblaze::SparseVector< ZeroVector< Type, TF, Tag >, TF > | |
►Cblaze::Expression< SparseVector< ZeroVector< Type, TF, Tag >, TF > > | |
Cblaze::ZeroVector< Type, TF, Tag > | Efficient implementation of an arbitrary sized zero vector |
Cblaze::VectorSerializer | Serializer for dense and sparse vectors |
►CVT | |
►Cblaze::Expression< VT > | |
►Cblaze::AddExpr< VT > | |
Cblaze::VecVecAddExpr< VT > | Base class for all vector/vector addition expression templates |
►Cblaze::BinaryMapExpr< VT > | |
Cblaze::VecVecMapExpr< VT > | Base class for all binary vector map expression templates |
►Cblaze::DivExpr< VT > | |
Cblaze::VecScalarDivExpr< VT > | Base class for all vector/scalar division expression templates |
Cblaze::VecVecDivExpr< VT > | Base class for all vector/vector division expression templates |
►Cblaze::EvalExpr< VT > | |
Cblaze::VecEvalExpr< VT > | Base class for all vector evaluation expression templates |
►Cblaze::GenExpr< VT > | |
Cblaze::VecGenExpr< VT > | Base class for all vector generator expression templates |
►Cblaze::KronExpr< VT > | |
Cblaze::VecVecKronExpr< VT > | Base class for all vector/vector Kronecker expression templates |
►Cblaze::MultExpr< VT > | |
Cblaze::MatVecMultExpr< VT > | Base class for all matrix/vector multiplication expression templates |
Cblaze::TVecMatMultExpr< VT > | Base class for all vector/matrix multiplication expression templates |
Cblaze::VecScalarMultExpr< VT > | Base class for all vector/scalar multiplication expression templates |
Cblaze::VecVecMultExpr< VT > | Base class for all vector/vector multiplication expression templates |
►Cblaze::NoAliasExpr< VT > | |
Cblaze::VecNoAliasExpr< VT > | Base class for all vector no-alias expression templates |
►Cblaze::NoSIMDExpr< VT > | |
Cblaze::VecNoSIMDExpr< VT > | Base class for all vector no-SIMD expression templates |
►Cblaze::ReduceExpr< VT > | |
Cblaze::MatReduceExpr< VT, RF > | Base class for all matrix reduction expression templates |
►Cblaze::RepeatExpr< VT > | |
Cblaze::VecRepeatExpr< VT, CRAs > | Base class for all vector repeater expression templates |
►Cblaze::SerialExpr< VT > | |
Cblaze::VecSerialExpr< VT > | Base class for all vector serial evaluation expression templates |
►Cblaze::SolveExpr< VT > | |
Cblaze::MatVecSolveExpr< VT > | Base class for all single LSE solver expression templates |
►Cblaze::SubExpr< VT > | |
Cblaze::VecVecSubExpr< VT > | Base class for all vector/vector subtraction expression templates |
►Cblaze::TransExpr< VT > | |
Cblaze::VecTransExpr< VT > | Base class for all vector transposition expression templates |
►Cblaze::UnaryMapExpr< VT > | |
Cblaze::VecMapExpr< VT > | Base class for all unary vector map expression templates |
Cblaze::CrossExpr< VT > | Base class for all cross product expression templates |
Cblaze::timing::WcPolicy | Timing policy for the measurement of the wall clock time |
Cblaze::XorAssign | Generic wrapper for bitwise XOR assignment |