Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
blais_mm::__copy< M, N >Noindex:
blais_mm::blais_mm::__copy< 0, N >Noindex:
mtl::__make_external< N >Noindex:
blais_mv::__mult< M, N, Orien >Noindex:
blais_mm::__mult< M, N, K >Noindex:
blais_mv::blais_mv::__mult< 0, N, row_tag >Noindex:
blais_mv::blais_mv::__mult< M, 0, column_tag >Noindex:
blais_mm::blais_mm::__mult< M, 0, K >Noindex:
blais_mv::blais_mv::__mult< M, N, column_tag >Noindex:
blais_mv::blais_mv::__mult< M, N, row_tag >Noindex:
blais_mv::__rank_one< M, N, Orien >Noindex:
blais_mv::blais_mv::__rank_one< 0, N, row_tag >Noindex:
blais_mv::blais_mv::__rank_one< M, 0, column_tag >Noindex:
blais_mv::blais_mv::__rank_one< M, N, column_tag >Noindex:
blais_mv::blais_mv::__rank_one< M, N, row_tag >Noindex:
blais_m::__recur_set< M, N >Noindex:
blais_m::blais_m::__recur_set< 0, N >Noindex:
algebra::AbelianGroup< Operation, Element >Concept AbelianGroup
mtl::abs_addNoindex:
mtl::abs_cmpNoindex:
blais_vv::add< N >
mtl::Addable< X, Y >Concept Addable: Binary operation
mtl::traits::algebraic_category< T >Meta-function for categorizing types into tag::scalar, tag::vector, and tag::matrix
mtl::AlgebraicCollection< T >Concept AlgebraicCollection: common requirements of matrices, vectors, and scalars in computations
mtl::tag::const_iter::allTag for const-iterator traversal of all elements of a collection
mtl::tag::iter::allTag for iterator traversal of all elements of a collection
mtl::AllTraversableMatrix< M >Concept AllTraversableMatrix: provides traversion over all elements
mtl::argument_result_conflictException for arguments with incompatible shapes, e.g. adding matrices and vectors
mtl::array< OneD, MemLoc >
mtl::array2D< OneD_ >Example: array2D.cc
mtl::ashape::ashape< T >Meta-function for algebraic shape of T
mtl::ashape::mtl::ashape::ashape< dense_vector< Value, Parameters > >Vectors must be distinguished between row and column vectors
associated_type
algebra::Associative< Operation, Element >Concept Associative
axiom
math::BanachSpace< N, Vector, Scalar >Concept BanachSpace
mtl::band_view< Matrix >
mtl::banded< MemLoc >
mtl::banded_offset< size_t, MM, NN >
mtl::banded_tag
mtl::banded_view< MemLoc >
mtl::banded_view_offset< size_t, MM, NN >
mtl::matrix::base_matrix< Elt, Parameters >Base class for other matrices, contains only very simple functionality that is used in all matrices
mtl::bin_op_expr< E1, E2 >Minimalistic expression template for binary operation: keeps only references
mtl::BinaryFunctor< T, U >Concept BinaryFunctor
mtl::BinaryStaticFunctor< T, U >Concept BinaryStaticFunctor
mtl::block1D< Vector, BN >
mtl::block2D< Block, OffsetGen >
mtl::block_view< Matrix, BM, BN >
mtl::tag::bottomTag for bottom of the category lattice
mtl::complexity_classes::cachedConstant complexity where the value is expected to be in cache with high probability
mtl::traits::category< Collection >Meta-function for categorizing MTL and external types
mtl::change_static_sizeException for trying to change a fixed size (to another value)
mtl::tag::col_majorCharacterizes column-major orientation in matrices and column vector in 1D
mtl::col_major_mask< K >Column-major mask for 2^K by 2^K base case
mtl::col_major_shark_mask< K, T >Row-major mask for 2^K by 2^K base case with 2^T shark teeth
mtl::tag::col_vectorTag for any MTL column vector (and user-declared MTL vectors)
mtl::Collection< T >Concept Collection
mtl::tag::collectionAny collection, i.e. vectors, matrices or higher-dimensional tensor
mtl::column_majorCategory: containers, selectors
mtl::column_matrix_traits< Matrix >
mtl::column_tag
mtl::ColumnTraversableMatrix< M >Concept ColumnTraversableMatrix: provides begin and end cursor to traverse columns
algebra::Commutative< Operation, Element >Concept Commutative
mtl::compressed< SizeType, MemLoc, IndexStyle >
mtl::compressed1D< T, SizeType, IND_OFFSET >
mtl::compressed2D< T, SizeType, IND_OFFSET >
mtl::matrix::compressed2D< Elt, Parameters >Compressed 2D matrix type
mtl::tag::compressed2DTag for compressed matrix in the category lattice
mtl::tag::compressed2D_viewTag for a view on a compressed matrix in the category lattice
mtl::compressed_iter< isConst, Value, Index, IND_OFFSET >
mtl::operation::compute_summand< Expr >Compute a summand in an expression
mtl::operation::mtl::operation::compute_summand< mat_cvec_times_expr< Matrix, CVector > >Specialization for matrix vector products
mtl::const_elt_ref< OneD >Noindex:
mtl::complexity_classes::constantConstant complexity
mtl::ConstantSizeAlgebraicCollection< T >Concept ConstantSizeAlgebraicCollection: extension of AlgebraicCollection with meta-functions
mtl::ConstantSizeCollection< T >Concept ConstantSizeCollection: size parameters of collection are completely given at compile time
mtl::ConstantSizeMatrix< T >Concept ConstantSizeMatrix
mtl::ConstantSizeVector< T >Concept ConstantSizeVector
mtl::tag::contiguous_denseTag for dense and contiguous collections
mtl::tag::contiguous_memoryTag for collections where values are stored contigously in memory
blais_vv::copy< N >
blais_mm::copy< M, N >
fast::count< NN >
fast::fast::count< 0 >Noindex:
mtl::matrix::mtl::matrix::crtp_assign< io::matrix_file< IFStream, OFStream >, Matrix >Assign content of a file to the matrix
mtl::matrix::mtl::matrix::crtp_assign< mat_mat_ele_times_expr< E1, E2 >, Matrix >Assign element-wise product
mtl::matrix::mtl::matrix::crtp_assign< mat_mat_minus_expr< E1, E2 >, Matrix >Assign difference by assigning first argument and subtracting second
mtl::matrix::mtl::matrix::crtp_assign< mat_mat_plus_expr< E1, E2 >, Matrix >Assign sum by assigning first argument and adding second
mtl::matrix::mtl::matrix::crtp_assign< mat_mat_times_expr< E1, E2 >, Matrix >Assign product by calling mult
mtl::matrix::mtl::matrix::crtp_assign< Value[Rows][Cols], Matrix >Assign c-style 2D-array, because it's easier to initialize
mtl::vector::mtl::vector::crtp_assign< Vector, mat_cvec_times_expr< E1, E2 > >Assign matrix vector product by calling mult
mtl::vector::detail::mtl::vector::detail::crtp_assign< Vector, Source, Cat, Cat >Assign vector to a vector
mtl::vector::detail::mtl::vector::detail::crtp_assign< Vector, Source, VCat, ashape::scal >Assign scalar to a vector by setting all values to the scalar
mtl::vector::mtl::vector::crtp_assign< Vector, Value[Rows]>Assign c-style 1D-array, because it's easier to initialize
mtl::matrix::crtp_matrix_assign< Matrix, ValueType, SizeType >Base class to provide matrix assignment operators generically
mtl::matrix::crtp_minus_assign< Source, Matrix >Assign-subtract matrix expressions by decrementally copying except for some special expressions
mtl::matrix::mtl::matrix::crtp_minus_assign< mat_mat_minus_expr< E1, E2 >, Matrix >Assign-subtracting difference by subtracting first argument and adding the second one
mtl::matrix::mtl::matrix::crtp_minus_assign< mat_mat_plus_expr< E1, E2 >, Matrix >Assign-subtract sum by adding both arguments
mtl::matrix::mtl::matrix::crtp_minus_assign< mat_mat_times_expr< E1, E2 >, Matrix >Assign-subtract product by calling gen_mult
mtl::vector::mtl::vector::crtp_minus_assign< Vector, mat_cvec_times_expr< E1, E2 > >Assign-add matrix vector product by calling mult
mtl::vector::detail::mtl::vector::detail::crtp_minus_assign< Vector, Source, Cat, Cat >Assign-add vector to a vector
mtl::matrix::crtp_plus_assign< Source, Matrix >Assign-add matrix expressions by incrementally copying except for some special expressions
mtl::matrix::mtl::matrix::crtp_plus_assign< mat_mat_plus_expr< E1, E2 >, Matrix >Assign-add sum by adding both arguments
mtl::vector::mtl::vector::crtp_plus_assign< Vector, mat_cvec_times_expr< E1, E2 > >Assign-add matrix vector product by calling mult
mtl::vector::detail::mtl::vector::detail::crtp_plus_assign< Vector, Source, Cat, Cat >Assign-add vector to a vector
mtl::vector::crtp_vector_assign< Vector, ValueType, SizeType >Base class to provide vector assignment operators generically
mtl::ashape::cvec< Value >Column vector as algebraic shape
mtl::dense< MemLoc >
mtl::tag::denseTag for any dense collection
mtl::dense1D< T, NN >
mtl::dense2D< T, OffsetGen, MM, NN >
mtl::tag::dense2DTag for (regular) dense matrix in the category lattice
mtl::dense2D_iterator< isConst, T, Offset, InnerOneD, OneD >Noindex:
mtl::tag::dense2D_viewTag for a view on a (regular) dense matrix in the category lattice
mtl::tag::dense_col_vectorTag for dense column vector in the category lattice
mtl::dense_el_cursor< Value >Cursor over every element of matrix, matrix row/column, or vector
mtl::traits::detail::dense_element_range_generator< Collection, Cursor, Complexity >Range generator that traverses all elements of some densely stored collection
mtl::dense_iterator< RandomAccessIterator, IND_OFFSET, SizeType >
mtl::tag::dense_row_vectorTag for dense row vector in the category lattice
mtl::dense_tag
mtl::diagonal< MemLoc >
mtl::diagonal_matrix< TwoDGen, IndexerGen >
mtl::diagonal_matrix_traits< Matrix >
mtl::diagonal_tag
mtl::dim_m< Matrix >Noindex:
mtl::dim_n< Vector >Noindex:
mtl::dimension< sizet, MM, NN >
algebra::Distributive< AddOp, MultOp, Element >Concept Distributive
mtl::traits::div_result< Op1, Op2 >Result type for dividing Op1 by Op2
mtl::traits::mtl::traits::div_result_aux< Op1, Op2,::mtl::ashape::cvec_scal_div >Divide column vector by scalar
mtl::traits::mtl::traits::div_result_aux< Op1, Op2,::mtl::ashape::mat_scal_div >Divide matrix by scalar
mtl::traits::mtl::traits::div_result_aux< Op1, Op2,::mtl::ashape::rvec_scal_div >Divide row vector by scalar
mtl::Divisible< X, Y >Concept Divisible: Binary operation
algebra::DivisionRing< AddOp, MultOp, Element >Concept DivisionRing
mtl::matrix::dmat_expr< Matrix >Base class for CRTP with dense matrices
mtl::do_scaledNoindex:
mtl::do_streamNoindex:
mtl::do_stridedNoindex:
mtl::do_transposeNoindex:
mtl::domain_errorDomain errors in MTL4
blais_vv::dot< N >
math::DotProduct< I, Vector, Scalar >Concept DotProduct
mtl::dynamic_uplo__Noindex:
mtl::elt_ref< OneD >Noindex:
mtl::ashape::emult_op< Shape1, Shape2 >Type of operation when values of Shape1 and Shape2 are multiplied (so far only for elements of collections)
mtl::ashape::emult_shape< Shape1, Shape2 >Algebraic shape of multiplication's result when elements of collections are multiplied
mtl::entry1< T >
mtl::envelope< MemLoc >
mtl::envelope2D< T >
mtl::ext_comp2D< T, SizeType, IND_OFFSET >
mtl::external2D< T, OffsetGen, MM, NN >
mtl::external_tag
mtl::external_vec< T, NN, SizeType >
algebra::Field< AddOp, MultOp, Element >Concept Field
mtl::gen_array2D< T >Noindex:
mtl::gen_banded_indexer< Orien, MM, NN, size_type >Noindex:
mtl::gen_banded_offset< M, N >Noindex:
mtl::gen_banded_view_offset< M, N >Noindex:
mtl::gen_block2D< Block, OffsetGen, M, N >Noindex:
mtl::gen_compressed2D< T, SizeType, INDEX, M, N >Noindex:
mtl::gen_dense2D< T, OffsetGen, M, N >Noindex:
mtl::gen_diagonal_indexer< Orien, MM, NN, size_type >Noindex:
mtl::gen_envelope2D< T, M, N >Noindex:
mtl::gen_ext_comp2D< T, SizeType, INDEX, M, N >Noindex:
mtl::gen_external2D< T, OffsetGen, M, N >Noindex:
mtl::gen_packed_offset< M, N >Noindex:
mtl::gen_rect_indexer< Orien, MM, NN, size_type >Noindex:
mtl::gen_rect_offset< M, N >Noindex:
mtl::gen_scaled2D< TwoD, T >Noindex:
mtl::gen_strided_band_view_offset< M, N >Noindex:
mtl::gen_strided_offset< M, N >Noindex:
mtl::generate_banded< T, Orientation, Storage, M, N >Noindex:
mtl::generate_diagonal< T, Storage, M, N >Noindex:
mtl::generate_external< T, Storage, M, N >Noindex:
mtl::generate_internal< T, Storage, M, N >Noindex:
mtl::generate_mask< IOrder, K, Orientation, T >
mtl::generate_oned< T, Storage >Noindex:
mtl::generate_rect< T, Orientation, Storage, M, N >Noindex:
mtl::generate_storage< T, Storage, M, N >Noindex:
mtl::generate_symmetric< T, Shape, Orien, Storage, M, N >Noindex:
mtl::generate_triangle< T, Shape, Orien, Storage, M, N >Noindex:
mtl::generate_uplo< Uplo >Noindex:
mtl::generators_errorNoindex:
mtl::generic_comp2D< ValsType, ValPtr, IndType, IndPtr, IND_OFFSET >
mtl::generic_dense2D< RepType, RepPtr, OffsetGen, MM, NN >
mtl::givens_rotation< T >
mtl::mtl::givens_rotation< std::complex< double > >
mtl::mtl::givens_rotation< std::complex< float > >
algebra::Group< Operation, Element >Concept Group
mtl::harwell_boeing_stream< T >
mtl::tag::has_1D_layoutTag for vectors with one-dimensional memory addressing
mtl::tag::has_2D_layoutTag for matrices with two-dimensional memory addressing
mtl::tag::has_cursorCollection with cursor
mtl::tag::has_fast_ra_cursorCollection with fast random-access cursor
mtl::tag::has_fast_ra_iteratorCollection with fast random-access iterator
mtl::tag::has_iteratorCollection with iterator
mtl::tag::has_ra_cursorCollection with random-access cursor
mtl::tag::has_ra_iteratorCollection with random-access iterator
mtl::tag::has_sub_matrixTag for matrices with sub_matrix function exist and doesn't say for which ranges it is defined
mtl::hermitian< Uplo >
mtl::tag::hermitian_multi_vectorTag for transposed multi_vector
mtl::hermitian_tag
math::HilbertSpace< I, Vector, Scalar, N >Concept HilbertSpace
mtl::i_order_mask< N >N-order mask of N bits
mtl::incompatible_shapeException for arguments with incompatible shapes, e.g. adding matrices and vectors
mtl::incompatible_sizeException for arguments with incompatible sizes
mtl::index_out_of_rangeException for indices out of range
mtl::complexity_classes::infiniteInfinite time complexity, which usually means that the operation or traversal is not available
math::InnerProduct< I, Vector, Scalar >Concept InnerProduct
mtl::InsertableMatrix< T >Concept InsertableMatrix: matrix that can be filled by means of inserter
mtl::internal_tag
mtl::tag::inverse_diagonalTag indicating that diagonal entries are stored as inverses
algebra::Inversion< Operation, Element >Concept Inversion
mtl::irangeClass to define a half open index ranges
mtl::is_32_base_case_col_major< Mask >Checks whether 32x32 base case of hybric matrix, defined by Mask, is a col-major matrix
mtl::is_32_base_case_row_major< Mask >Checks whether 32x32 base case of hybric matrix, defined by Mask, is a row-major matrix
mtl::is_k_power_base_case_col_major< K, Mask >Checks whether 2^K by 2^K base case of hybric matrix, defined by Mask, is a column-major matrix
mtl::is_k_power_base_case_col_major_t_shark< K, T, Mask >
mtl::is_k_power_base_case_row_major< K, Mask >Checks whether 2^K by 2^K base case of hybric matrix, defined by Mask, is a row-major matrix
mtl::is_k_power_base_case_row_major_t_shark< K, T, Mask >
mtl::traits::is_row_major< Parameter >Meta-function whether a tag is row_major or col_major
mtl::IteratableSubMatrix< Tag, ITag, M >Concept IteratableSubMatrix: provides iteration over elements within rows or columns of matrices
iterator_adaptor< SubClass, Iterator >
mtl2lapack::lapack_matrix< T, External >
mtl::left_sideNoindex:
mtl::light1D< T, NN, IND_OFFSET >
mtl::linalg_traits< Linalg >
mtl::linalg_vec< RepType, RepPtr, NN >
mtl::complexity_classes::linearLinear
mtl::complexity_classes::linear_cachedProduct of linear and cached
math::LinearOperator< Operator, VectorDomain, VectorImage >Concept LinearOperator
mtl::linked_list
mtl::complexity_classes::log_nLogarithmic complexity
mtl::logic_errorException for logic errors that doesn't fit into specific categories
mtl::lower__Noindex:
mtl::lsb_bits< N, Value >Last N bits of Value
mtl::Magnitude< T >Concept/Type-trait for magnitudes of scalar values
mtl::mtl::Magnitude< std::complex< T > >Specialization for complex numbers
mtl::MajorTraversableMatrix< M >Concept MajorTraversableMatrix: traversable on major dimension
mtl::ashape::mat< Value >Matrix as algebraic shape
mtl::matrix::mat_expr< Matrix >Base class for CRTP with matrices
mtl::Matrix< T >Concept Matrix
mtl::tag::matrixTag for any MTL matrix (and user-declared MTL matrices)
mtl::matrix_implementation< TwoDGen, IndexerGen >
mtl::io::matrix_market_istreamInput file stream for files in matrix market format
mtl::matrix_market_stream< T >
mtl::matrix_not_squareException for arguments with incompatible sizes
mtl::matrix_traits< Matrix >
mtl::MatrixInserter< T >Concept MatrixInserter: classes that enable efficient insertion into matrices, esp. compressed sparse
mtl::complexity_classes::min< X, Y >Minimal complexity class
mtl::MinorTraversableMatrix< M >Concept MinorTraversableMatrix: traversable on minor dimension
mtl::missing_diagonalException for arguments with incompatible sizes
mtl::modified_givens< T >
algebra::Monoid< Operation, Element >Concept Monoid
mtl::tag::morton_denseTag for Morton-order matrix in the category lattice
mtl::tag::morton_viewTag for a view on a Morton-order matrix in the category lattice
mtl::matrix< T, Shape, Storage, Orientation >Tparam: EltType - Valid choices for this argument include double, complex<float>, and bool. In essence, any builtin or user defined type can be used for the EltType, however, if one uses the matrix with a particular algorithm, the EltType must support the operations required by the algorithm. For MTL algorithms these typically include the usual numerical operators such as addition and multiplication. The std::complex class is a good example of what is required in a numerical type. The documentation for each algorithm will include the requirements on the element type
blais_mm::mult< M, N, K >
blais_mv::mult< M, N >
mtl::traits::mult_result< Op1, Op2 >Result type for multiplying arguments of types Op1 and Op2
mtl::traits::mult_result_aux< Op1, Op2, MultOp >Result type for multiplying arguments of types Op1 and Op2
mtl::traits::mtl::traits::mult_result_aux< Op1, Op2,::mtl::ashape::mat_cvec_mult >Multiply matrix with column vector
mtl::traits::mtl::traits::mult_result_aux< Op1, Op2,::mtl::ashape::mat_mat_mult >Multiply matrices
mtl::traits::mtl::traits::mult_result_aux< Op1, Op2,::mtl::ashape::mat_scal_mult >Scale matrix from right needs functor for scaling from right
mtl::traits::mtl::traits::mult_result_aux< Op1, Op2,::mtl::ashape::scal_mat_mult >Scale matrix from left
mtl::matrix::multi_vector< Vector >Matrix constituting of set of column vectors (under development)
mtl::tag::multi_vectorTag for multi_vector
mtl::Multiplicable< X, Y >Concept Multiplicable: Binary operation
mtl::MutableCollection< T >Concept MutableCollection
mtl::MutableMatrix< T >Concept MutableMatrix
mtl::MutableVector< T >Concept MutableVector
mtl::complexity_classes::n_log_nLogarithm times linear, i.e. n * log n
mtl::complexity_classes::n_polylog_nPolynomial logarithm times linear, i.e. n * log^k n
mtl::ashape::ndefUndefined shape, e.g., for undefined results of operations
mtl::NonZeroTraversableSubMatrix< Tag, M >Concept NonZeroTraversableSubMatrix: provides traversion of non-zero in rows or columns of matrices
math::Norm< N, Vector, Scalar >Concept Norm
mtl::not_strideable
mtl::traits::num_cols< Collection >General declaration, used to disable unsupported types
mtl::traits::mtl::traits::num_cols< std::vector< Value > >Num_cols implementation for STL vectors
mtl::traits::mtl::traits::num_cols< Value[Rows][Cols]>Num_cols implementation for (2D and higher) arrays interpreted as matrices
mtl::traits::mtl::traits::num_cols< Value[Size]>Num_cols implementation for (1D) arrays interpreted as vectors
mtl::traits::num_rows< Collection >General declaration, used to disable unsupported types
mtl::traits::mtl::traits::num_rows< std::vector< Value > >Num_rows implementation for STL vectors
mtl::traits::mtl::traits::num_rows< Value[Rows][Cols]>Num_rows implementation for (2D and higher) arrays interpreted as matrices
mtl::traits::mtl::traits::num_rows< Value[Size]>Num_rows implementation for (1D) arrays interpreted as vectors
mtl::tag::iter::nzTag for iterator traversal of non-zero elements of a collection
mtl::tag::const_iter::nzTag for const-iterator traversal of non-zero elements of a collection
mtl::oned_tag
mtl::OrientedCollection< T >Concept OrientedCollection: collections with concept-awareness in terms of associated type
mtl::packed< MemLoc >
mtl::packed_offset< size_t, MM, NN >
mtl::utility::papi_errorException for errors with PAPI, is sub-divided further
mtl::matrix::parameters< Orientation, Index, Dimensions, OnStack >Type for bundling template parameters of common matrix types
mtl::complexity_classes::plus< X, Y >Adding complexities of two operations is the maximal complexity of both operations
mtl::complexity_classes::polylog_nPolynomial logarithm, i.e. log^k n
mtl::complexity_classes::polynomialAll complexities larger than quadratic (< infinite) including n^2 log^k n
mtl::tag::qsub_dividableSub-dividable into quadrants, i.e. arbitrary sub-matrices not necessarily supported but recursion works
mtl::range_errorException for invalid range definitions, esp. in constructors
blais_mv::rank_one< M, N >
math::RealOperator< Operator, VectorDomain, VectorImage >Concept RealOperator
mtl::rect_offset< size_t, MM, NN >
mtl::rectangle< MM, NN >
mtl::rectangle_tag
mtl::matrix::recursator< Matrix >
mtl::tag::regular_diagonalTag indicating that diagonal is stored regularly
mtl::matrix::traits::reorder< Value >Return type of mtl::matrix::reorder
mtl::ResizeableMatrix< T >Concept ResizeableMatrix
mtl::right_sideNoindex:
algebra::Ring< AddOp, MultOp, Element >Concept Ring
algebra::RingWithIdentity< AddOp, MultOp, Element >Concept RingWithIdentity
mtl::tag::row_majorCharacterizes row-major orientation in matrices and row vector in 1D
mtl::row_majorCategory: containers, selectors
mtl::row_major_mask< K >Row-major mask for 2^K by 2^K base case
mtl::row_major_shark_mask< K, T >Row-major mask for 2^K by 2^K base case with 2^T shark teeth
mtl::row_matrix_traits< Matrix >
mtl::row_tag
mtl::tag::row_vectorTag for any MTL row vector (and user-declared MTL vectors)
mtl::RowTraversableMatrix< M >Concept RowTraversableMatrix: provides begin and end cursor to traverse rows
mtl::runtime_errorException for run-time errors that doesn't fit into specific categories
mtl::ashape::rvec< Value >Row vector as algebraic shape
mtl::same_mask< Mask1, Mask2 >Compares two masks
mtl::ashape::scalScalar algebraic shape
mtl::tag::scalar
mtl::scale_iterator< RandomAccessIterator, T >
mtl::scaled1D< RandomAccessContainerRef >
mtl::scaled2D< TwoD, T >
mtl::scaled2D_iter< twod_iter, T, ValType, Ref >Noindex:
math::SelfAdjointOperator< Operator, VectorDomain, VectorImage >Concept SelfAdjointOperator
algebra::SemiGroup< Operation, Element >Concept SemiGroup
math::SemiNorm< N, Vector, Scalar >Concept SemiNorm
blais_v::set< N >
blais_m::set< M, N >
mtl::traits::size< Collection >General declaration, used to disable unsupported types
mtl::traits::mtl::traits::size< std::vector< Value > >Size implementation for STL vectors
mtl::traits::mtl::traits::size< Value[Rows][Cols]>Size implementation for (2D and higher) arrays interpreted as matrices
mtl::traits::mtl::traits::size< Value[Size]>Size implementation for (1D) arrays interpreted as vectors
algebra::SkewField< AddOp, MultOp, Element >Concept SkewField
mtl::matrix::smat_expr< Matrix >Base class for CRTP with sparse matrices
mtl::sp1D_index_array< RepType >Noindex:
mtl::tag::sparseTag for any sparse collection
mtl::sparse1D< RepType >
mtl::sparse_iterator< Iterator, T >
mtl::sparse_pair
mtl::sparse_tag
mtl::sqr_Noindex:
mtl::sqr_addNoindex:
mtl::tag::std_vectorTag to handle std::vector in the category lattice
mtl::strideable
mtl::strided1D< RandomAccessContainerRef >
mtl::strided_band_view_offset< size_t, MM, NN >
mtl::strided_dense_el_const_iterator< Value >Iterator going in strides over element of matrix, matrix row/column, or vector
mtl::strided_dense_el_cursor< Value >Cursor going in strides over element of matrix, matrix row/column, or vector
mtl::strided_dense_el_iterator< Value >Iterator going in strides over element of matrix, matrix row/column, or vector
mtl::strided_iterator< RandomAccessIterator, isConst >
mtl::strided_offset< size_t, MM, NN >
mtl::tag::sub_dividableTag for sub-dividable matrix, i.e. sub_matrix works
mtl::Subtractable< X, Y >Concept Subtractable: Binary operation
mtl::symmetric< Uplo >
mtl::symmetric_tag
mtl::symmetric_view< Matrix, Uplo >
math::SymmetricOperator< Operator, VectorDomain, VectorImage >Concept SymmetricOperator
mtl::complexity_classes::times< X, Y >Product of complexities
mtl::tag::transposed_multi_vectorTag for transposed multi_vector
mtl::TraversableCollection< Tag, C >Concept TraversableCollection: collections that can be traversed by cursor or iterator
mtl::TraversableMutableCollection< Tag, C >Concept TraversableMutableCollection: collections that can be traversed by (mutable) iterator
mtl::tree
mtl::tri_view< Uplo >
mtl::triangle< Uplo >
mtl::triangle_tag
mtl::triangle_view< Matrix, UL >
mtl::twod_tag
mtl::UnaryFunctor< T >Concept UnaryFunctor
mtl::UnaryStaticFunctor< T >Concept UnaryStaticFunctor
mtl::unexpected_resultException for a result that is not what it should be
mtl::tag::unit_diagonalTag indicating that diagonal contains unit elements
mtl::unit_lower__Noindex:
mtl::unit_upper__Noindex:
mtl::tag::universeTag for all types
mtl::tag::universe_diagonalCommon base for diagonal tags
mtl::tag::unknownFor non-MTL types with category not explicitly defined
mtl::operations::update_assign_mode< Assign, Value >Compute updater that corresponds to assign_mode
mtl::upper__Noindex:
mtl::vector::vec_const_ref_expr< Vector >Class for providing interface for a vector given as reference
mtl::traits::vec_mult_result< Op1, Op2 >Result type for multiplying arguments of types Op1 and Op2
mtl::traits::vec_mult_result_aux< Op1, Op2, MultOp >Result type for multiplying arguments of types Op1 and Op2
mtl::traits::mtl::traits::vec_mult_result_aux< Op1, Op2,::mtl::ashape::cvec_scal_mult >Scale column vector from right
mtl::traits::mtl::traits::vec_mult_result_aux< Op1, Op2,::mtl::ashape::rvec_scal_mult >Scale row vector from right
mtl::traits::mtl::traits::vec_mult_result_aux< Op1, Op2,::mtl::ashape::scal_cvec_mult >Scale column vector from left
mtl::traits::mtl::traits::vec_mult_result_aux< Op1, Op2,::mtl::ashape::scal_rvec_mult >Scale row vector from left
mtl::Vector< T >Concept Vector
mtl::tag::vectorTag for any MTL vector (and user-declared MTL vectors)
math::VectorSpace< Vector, Scalar >Concept VectorSpace
mtl::z_order_mask< N >Z-order mask of N bits





Class List -- MTL 4 -- Peter Gottschling and Andrew Lumsdaine -- Generated on 19 May 2009 by Doxygen 1.5.5 -- Copyright 2007 by the Trustees of Indiana University.