Main name space for Matrix Template Library. More...

Namespaces
namespace	ashape
	Namespace for algebraic shapes; used for sophisticated dispatching between operations.
namespace	assign
	Namespace for static assignment functors.
namespace	complexity_classes
	Namespace for complexity classes.
namespace	concept
	Namespace for concepts.
namespace	fixed
	Namespace for compile-time parameters, e.g. matrix dimensions.
namespace	io
	Namespace for I/O operations.
namespace	matrix
	Namespace for matrices and views and operations exclusively on matrices.
namespace	non_fixed
	Namespace for run-time parameters, e.g. matrix dimensions.
namespace	operations
	Namespace for operations (if not defined in mtl)
namespace	recursion
	Namespace for recursive operations and types with recursive memory layout.
namespace	sfunctor
	Namespace for functors with static function apply and fully typed paramaters.
namespace	tag
	Namespace for tags used for concept-free dispatching.
namespace	tfunctor
	Namespace for functors with application operator and fully typed paramaters.
namespace	traits
	Namespace for type traits.
namespace	utility
	Namespace for utilities.
namespace	vector
	Namespace for vectors and views and operations exclusively on vectors.
namespace	wrec
	Namespace for implementations using recursators.
Classes
class	array2D
	example: array2D.cc More...
struct	gen_array2D
	noindex: More...
struct	gen_banded_indexer
	noindex: More...
class	block1D
class	block2D
struct	gen_block2D
	noindex: More...
class	compressed1D
class	generic_comp2D
class	compressed2D
class	ext_comp2D
struct	gen_compressed2D
	noindex: More...
struct	gen_ext_comp2D
	noindex: More...
class	compressed_iter
class	dense1D
class	rect_offset
struct	gen_rect_offset
	noindex: More...
class	strided_offset
struct	gen_strided_offset
	noindex: More...
class	banded_view_offset
struct	gen_banded_view_offset
	noindex: More...
class	strided_band_view_offset
struct	gen_strided_band_view_offset
	noindex: More...
class	banded_offset
struct	gen_banded_offset
	noindex: More...
class	packed_offset
struct	gen_packed_offset
	noindex: More...
class	dense2D_iterator
	noindex: More...
class	generic_dense2D
class	dense2D
struct	gen_dense2D
	noindex: More...
class	external2D
struct	gen_external2D
	noindex: More...
class	dense_iterator
struct	gen_diagonal_indexer
	noindex: More...
class	dim_n
	noindex: More...
class	dim_m
	noindex: More...
class	dimension
struct	entry1
class	elt_ref
	noindex: More...
class	const_elt_ref
	noindex: More...
class	envelope2D
struct	gen_envelope2D
	noindex: More...
class	harwell_boeing_stream
class	light1D
class	linalg_vec
class	external_vec
struct	__make_external
	noindex: More...
class	rectangle
struct	banded
struct	diagonal
struct	triangle
struct	symmetric
struct	hermitian
struct	row_major
	category: containers, selectors More...
struct	column_major
	category: containers, selectors More...
struct	dense
struct	packed
struct	banded_view
struct	compressed
struct	array
struct	envelope
struct	sparse_pair
struct	tree
struct	linked_list
struct	generators_error
	noindex: More...
struct	generate_oned
	noindex: More...
struct	generate_internal
	noindex: More...
struct	generate_external
	noindex: More...
struct	generate_storage
	noindex: More...
struct	generate_rect
	noindex: More...
struct	generate_banded
	noindex: More...
struct	generate_diagonal
	noindex: More...
struct	generate_uplo
	noindex: More...
struct	generate_triangle
	noindex: More...
struct	generate_symmetric
	noindex: More...
struct	matrix
	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. More...
struct	block_view
struct	band_view
struct	triangle_view
struct	tri_view
struct	symmetric_view
class	matrix_implementation
class	diagonal_matrix
class	matrix_market_stream
struct	matrix_traits
struct	row_matrix_traits
struct	column_matrix_traits
struct	diagonal_matrix_traits
class	rectangle_tag
class	banded_tag
class	triangle_tag
class	symmetric_tag
class	hermitian_tag
class	diagonal_tag
class	external_tag
class	internal_tag
struct	row_tag
struct	column_tag
struct	dense_tag
struct	sparse_tag
struct	oned_tag
struct	twod_tag
struct	linalg_traits
struct	strideable
struct	not_strideable
struct	do_transpose
	noindex: More...
struct	do_strided
	noindex: More...
struct	do_scaled
	noindex: More...
struct	do_stream
	noindex: More...
class	right_side
	noindex: More...
class	left_side
	noindex: More...
struct	abs_add
	noindex: More...
struct	sqr_add
	noindex: More...
struct	sqr_
	noindex: More...
struct	abs_cmp
	noindex: More...
class	givens_rotation
class	givens_rotation< std::complex< double > >
class	givens_rotation< std::complex< float > >
class	modified_givens
struct	gen_rect_indexer
	noindex: More...
class	scale_iterator
class	scaled1D
class	scaled2D_iter
	noindex: More...
class	scaled2D
struct	gen_scaled2D
	noindex: More...
class	sp1D_index_array
	noindex: More...
class	sparse1D
class	sparse_iterator
class	strided1D
class	strided_iterator
struct	upper__
	noindex: More...
struct	unit_upper__
	noindex: More...
struct	lower__
	noindex: More...
struct	unit_lower__
	noindex: More...
struct	dynamic_uplo__
	noindex: More...
struct	Collection
	Concept Collection. More...
struct	MutableCollection
	Concept MutableCollection. More...
struct	ConstantSizeCollection
	Concept ConstantSizeCollection: size parameters of collection are completely given at compile time. More...
struct	AlgebraicCollection
	Concept AlgebraicCollection: common requirements of matrices, vectors, and scalars in computations. More...
struct	ConstantSizeAlgebraicCollection
	Concept ConstantSizeAlgebraicCollection: extension of AlgebraicCollection with meta-functions. More...
struct	TraversableCollection
	Concept TraversableCollection: collections that can be traversed by cursor or iterator. More...
struct	TraversableMutableCollection
	Concept TraversableMutableCollection: collections that can be traversed by (mutable) iterator. More...
struct	OrientedCollection
	Concept OrientedCollection: collections with concept-awareness in terms of associated type. More...
struct	Magnitude
	Concept/Type-trait for magnitudes of scalar values. More...
struct	Magnitude< std::complex< T > >
	Specialization for complex numbers. More...
struct	Matrix
	Concept Matrix. More...
struct	MatrixInserter
	Concept MatrixInserter: classes that enable efficient insertion into matrices, esp. compressed sparse. More...
struct	InsertableMatrix
	Concept InsertableMatrix: matrix that can be filled by means of inserter. More...
struct	MutableMatrix
	Concept MutableMatrix. More...
struct	ConstantSizeMatrix
	Concept ConstantSizeMatrix. More...
struct	ResizeableMatrix
	Concept ResizeableMatrix. More...
struct	RowTraversableMatrix
	Concept RowTraversableMatrix: provides begin and end cursor to traverse rows. More...
struct	ColumnTraversableMatrix
	Concept ColumnTraversableMatrix: provides begin and end cursor to traverse columns. More...
struct	MajorTraversableMatrix
	Concept MajorTraversableMatrix: traversable on major dimension. More...
struct	MinorTraversableMatrix
	Concept MinorTraversableMatrix: traversable on minor dimension. More...
struct	AllTraversableMatrix
	Concept AllTraversableMatrix: provides traversion over all elements. More...
struct	NonZeroTraversableSubMatrix
	Concept NonZeroTraversableSubMatrix: provides traversion of non-zero in rows or columns of matrices. More...
struct	IteratableSubMatrix
	Concept IteratableSubMatrix: provides iteration over elements within rows or columns of matrices. More...
struct	StaticUnaryFunctor
	Concept/Type-trait for static unary functors. More...
struct	StaticBinaryFunctor
	Concept/Type-trait for static binary functors. More...
class	Addable
	Concept Addable: Binary operation. More...
class	Subtractable
	Concept Subtractable: Binary operation. More...
class	Multiplicable
	Concept Multiplicable: Binary operation. More...
class	Divisible
	Concept Divisible: Binary operation. More...
struct	UnaryFunctor
	Concept UnaryFunctor. More...
struct	UnaryStaticFunctor
	Concept UnaryStaticFunctor. More...
struct	BinaryFunctor
	Concept BinaryFunctor. More...
struct	BinaryStaticFunctor
	Concept BinaryStaticFunctor. More...
struct	Vector
	Concept Vector. More...
struct	MutableVector
	Concept MutableVector. More...
struct	ConstantSizeVector
	Concept ConstantSizeVector. More...
struct	bin_op_expr
	Minimalistic expression template for binary operation: keeps only references. More...
struct	ColumnInMatrix
	Type of column in matrix as vector if accessible. More...
struct	RowInMatrix
	Type of row in matrix as vector if accessible. More...
struct	static_num_cols
	Number of columns given at compile time. More...
struct	static_num_cols< Value[Size]>
	static_num_cols implementation for (1D) arrays interpreted as vectors More...
struct	static_num_cols< Value[Rows][Cols]>
	static_num_cols implementation for (2D and higher) arrays interpreted as matrices More...
struct	static_num_rows
	Number of rows given at compile time. More...
struct	static_num_rows< Value[Size]>
	static_num_rows implementation for (1D) arrays interpreted as vectors More...
struct	static_num_rows< Value[Rows][Cols]>
	static_num_rows implementation for (2D and higher) arrays interpreted as matrices More...
struct	static_size
	Number of rows times columns given at compile time. More...
struct	lsb_bits
	Last N bits of Value. More...
struct	same_mask
	Compares two masks. More...
struct	row_major_mask
	Row-major mask for 2^K by 2^K base case. More...
struct	col_major_mask
	Column-major mask for 2^K by 2^K base case. More...
struct	is_k_power_base_case_row_major
	Checks whether 2^K by 2^K base case of hybric matrix, defined by Mask, is a row-major matrix. More...
struct	is_k_power_base_case_col_major
	Checks whether 2^K by 2^K base case of hybric matrix, defined by Mask, is a column-major matrix. More...
struct	is_32_base_case_row_major
	Checks whether 32x32 base case of hybric matrix, defined by Mask, is a row-major matrix. More...
struct	is_32_base_case_col_major
	Checks whether 32x32 base case of hybric matrix, defined by Mask, is a col-major matrix. More...
struct	row_major_shark_mask
	Row-major mask for 2^K by 2^K base case with 2^T shark teeth. More...
struct	col_major_shark_mask
	Row-major mask for 2^K by 2^K base case with 2^T shark teeth. More...
struct	is_k_power_base_case_row_major_t_shark
struct	is_k_power_base_case_col_major_t_shark
struct	i_order_mask
	N-order mask of N bits. More...
struct	z_order_mask
	Z-order mask of N bits. More...
class	generate_mask
struct	dense_el_cursor
	Cursor over every element of matrix, matrix row/column, or vector. More...
struct	index_out_of_range
	Exception for indices out of range. More...
struct	range_error
	Exception for invalid range definitions, esp. in constructors. More...
struct	domain_error
	Domain errors in MTL4. More...
struct	incompatible_size
	Exception for arguments with incompatible sizes. More...
struct	need_nonempty
	Exception for arguments that shall not be empty. More...
struct	change_static_size
	Exception for trying to change a fixed size (to another value) More...
struct	argument_result_conflict
	Exception for arguments with incompatible shapes, e.g. adding matrices and vectors. More...
struct	incompatible_shape
	Exception for arguments with incompatible shapes, e.g. adding matrices and vectors. More...
struct	matrix_not_square
	Exception for arguments with incompatible sizes. More...
struct	matrix_too_small
	Exception for matrices too small for certain algorithms. More...
struct	matrix_singular
	Exception for singular matrices in solvers. More...
struct	missing_diagonal
	Exception for arguments with incompatible sizes. More...
struct	access_during_insertion
	Accessing (illegally) matrix or vector during insertion phase (dense non-distributed can be accessed always) More...
struct	unexpected_result
	Exception for a result that is not what it should be. More...
struct	runtime_error
	Exception for run-time errors that doesn't fit into specific categories. More...
struct	logic_error
	Exception for logic errors that doesn't fit into specific categories. More...
struct	io_error
	Exception for I/O errors in general. More...
struct	file_not_found
	File not found. More...
class	irange
	Class to define a half open index ranges. More...
struct	make_in_copy_or_reference
	Helper class to avoid avoidable copies for input parameters. More...
struct	make_out_copy_or_reference
	Helper class to avoid avoidable copies for output parameters. More...
struct	make_in_out_copy_or_reference
	Helper class to avoid avoidable copies for input-output parameters. More...
struct	strided_dense_el_cursor
	Cursor going in strides over element of matrix, matrix row/column, or vector. More...
struct	strided_dense_el_const_iterator
	Iterator going in strides over element of matrix, matrix row/column, or vector. More...
struct	strided_dense_el_iterator
	Iterator going in strides over element of matrix, matrix row/column, or vector. More...
Functions
template<class DenseMatrix , class Pvector >
int	lu_factor (DenseMatrix &A, Pvector &ipvt)
template<class DenseMatrix , class VectorB , class VectorX , class Pvector >
void	lu_solve (const DenseMatrix &LU, const Pvector &pvector, const VectorB &b, VectorX &x)
template<class DenseMatrixLU , class DenseMatrix , class Pvector >
void	lu_inverse (const DenseMatrixLU &LU, const Pvector &pvector, DenseMatrix &AInv)
void	read_dense_matlab (matlab_dense &A, char matrix_name, const char file)
void	write_dense_matlab (matlab_dense &A, char matrix_name, const char file)
void	read_sparse_matlab (matlab_sparse &A, char matrix_name, const char file)
void	write_sparse_matlab (matlab_sparse &A, char matrix_name, const char file)
template<class Matrix >
block_view< Matrix, 0, 0 >::type	blocked (const Matrix &A, int bm, int bn)
template<class Matrix , int BM, int BN>
block_view< Matrix, BM, BN >::type	blocked (const Matrix &A, blk< BM, BN >)
template<class Matrix >
rows_type< Matrix >::type	rows (const Matrix &A)
template<class Matrix >
columns_type< Matrix >::type	columns (const Matrix &A)
template<class Matrix >
Matrix::transpose_type	trans (const Matrix &A)
template<class Vector >
linalg_traits< Vector >::value_type	sum (const Vector &x)
template<class LinalgObj , class T >
void	scale (MTL_OUT(LinalgObj) A, const T &alpha)
template<class Matrix , class T >
void	set_diagonal (MTL_OUT(Matrix) A_, const T &alpha)
template<class Vector >
linalg_traits< Vector > ::magnitude_type	two_norm (const Vector &x)
template<class Vector >
linalg_traits< Vector >::value_type	sum_squares (const Vector &x)
template<class Matrix >
linalg_traits< Matrix > ::magnitude_type	major_norm__ (const Matrix &A)
	noindex:
template<class Matrix >
linalg_traits< Matrix > ::magnitude_type	minor_norm__ (const Matrix &A)
	noindex:
template<class Matrix >
linalg_traits< Matrix > ::magnitude_type	one_norm__ (const Matrix &A, column_tag)
	noindex:
template<class Matrix >
linalg_traits< Matrix > ::magnitude_type	one_norm__ (const Matrix &A, row_tag)
	noindex:
template<class LinalgObj >
linalg_traits< LinalgObj > ::magnitude_type	one_norm (const LinalgObj &A)
template<class Matrix >
linalg_traits< Matrix > ::magnitude_type	infinity_norm__ (const Matrix &A, row_tag)
	noindex:
template<class Matrix >
linalg_traits< Matrix > ::magnitude_type	infinity_norm__ (const Matrix &A, column_tag)
	noindex:
template<class LinalgObj >
linalg_traits< LinalgObj > ::magnitude_type	infinity_norm (const LinalgObj &A)
template<class Vec >
Vec::size_type	max_index (const Vec &x)
template<class Vec >
Vec::size_type	max_abs_index (const Vec &x)
template<class Vec >
Vec::size_type	min_index (const Vec &x)
template<class Vec >
Vec::size_type	min_abs_index (const Vec &x)
template<class VectorT >
VectorT::value_type	max (const VectorT &x)
template<class VectorT >
VectorT::value_type	min (const VectorT &x)
template<class Matrix >
void	transpose (MTL_OUT(Matrix) A_) MTL_THROW_ASSERTION
template<class MatA , class MatB >
void	transpose (const MatA &A, MTL_OUT(MatB) B_) MTL_THROW_ASSERTION
	precond: `B(i,j) = 0 & B = A^T`
template<class Matrix , class VecX , class VecY , class VecZ >
void	mult (const Matrix &A, const VecX &x, const VecY &y, MTL_OUT(VecZ) z_) MTL_THROW_ASSERTION
template<class Matrix , class VecX , class VecY >
void	mult_dim__ (const Matrix &A, const VecX &x, VecY &y, oned_tag) MTL_THROW_ASSERTION
template<class MatA , class MatB , class MatC , class Orien >
void	simple_mult (const MatA &A, const MatB &B, MatC &C, dense_tag, Orien)
	noindex:
template<class MatA , class MatB , class MatC >
void	symm_simple_mult (const MatA &A, const MatB &B, MatC &C, row_tag)
	noindex:
template<class MatA , class MatB , class MatC >
void	symm_simple_mult (const MatA &A, const MatB &B, MatC &C, column_tag)
	noindex:
template<class MatA , class MatB , class MatC >
void	matmat_mult (const MatA &A, const MatB &B, MatC &C, symmetric_tag)
	noindex:
template<class MatA , class MatB , class MatC >
void	matmat_mult (const MatA &A, const MatB &B, MatC &C, triangle_tag)
	noindex
template<class MatA , class MatB , class MatC >
void	matmat_mult (const MatA &A, const MatB &B, MatC &C, rectangle_tag)
	noindex:
template<class MatA , class MatB , class MatC >
void	mult_dim__ (const MatA &A, const MatB &B, MatC &C, twod_tag)
template<class LinalgA , class LinalgB , class LinalgC >
void	mult (const LinalgA &A, const LinalgB &B, MTL_OUT(LinalgC) C_)
	noindex:
template<class TriMatrix , class VecX >
void	tri_solve__ (const TriMatrix &T, VecX &x, column_tag)
	noindex:
template<class TriMatrix , class VecX >
void	tri_solve__ (const TriMatrix &T, VecX &x, row_tag)
	noindex:
template<class TriMatrix , class VecX >
void	tri_solve (const TriMatrix &T, MTL_OUT(VecX) x_) MTL_THROW_ASSERTION
template<class MatT , class MatB >
void	tri_solve__ (const MatT &T, MatB &B, left_side)
	noindex:
template<class MatT , class MatB >
void	tri_solve__ (const MatT &T, MatB &B, right_side)
	noindex:
template<class MatT , class MatB , class Side >
void	tri_solve (const MatT &T, MTL_OUT(MatB) B, Side s)
template<class Matrix , class VecX , class VecY >
void	rank_one_update (MTL_OUT(Matrix) A_, const VecX &x, const VecY &y) MTL_THROW_ASSERTION
template<class Matrix , class VecX , class VecY >
void	rank_two_update (MTL_OUT(Matrix) A_, const VecX &x, const VecY &y) MTL_THROW_ASSERTION
template<class VecX , class VecY >
void	scatter (const VecX &x, MTL_OUT(VecY) y_) MTL_THROW_ASSERTION
template<class VecX , class VecY >
void	gather (const VecX &x, MTL_OUT(VecY) y_) MTL_THROW_ASSERTION
template<class LinalgA , class LinalgB >
void	copy (const LinalgA &A, MTL_OUT(LinalgB) B_) MTL_THROW_ASSERTION
template<class VecX , class VecY , class VecZ >
void	add (const VecX &x, const VecY &y, MTL_OUT(VecZ) z_) MTL_THROW_ASSERTION
template<class VecW , class VecX , class VecY , class VecZ >
void	add (const VecX &x, const VecY &y, const VecZ &z, MTL_OUT(VecW) w_) MTL_THROW_ASSERTION
template<class LinalgA , class LinalgB >
void	add (const LinalgA &A, MTL_OUT(LinalgB) B_) MTL_THROW_ASSERTION
template<class VecX , class VecY , class VecZ >
void	ele_mult (const VecX &x, const VecY &y, MTL_OUT(VecZ) z_) MTL_THROW_ASSERTION
template<class MatA , class MatB >
void	ele_mult (const MatA &A, MTL_OUT(MatB) B_) MTL_THROW_ASSERTION
template<class VecX , class VecY , class VecZ >
void	ele_div (const VecX &x, const VecY &y, MTL_OUT(VecZ) z_) MTL_THROW_ASSERTION
template<class LinalgA , class LinalgB >
void	swap (MTL_OUT(LinalgA) A, MTL_OUT(LinalgB) B) MTL_THROW_ASSERTION
template<class VecX , class VecY , class T >
T	dot (const VecX &x, const VecY &y, T s) MTL_THROW_ASSERTION
template<class VecX , class VecY >
VecX::value_type	dot (const VecX &x, const VecY &y) MTL_THROW_ASSERTION
template<class VecX , class VecY , class T >
T	dot_conj (const VecX &x, const VecY &y, T s) MTL_THROW_ASSERTION
template<class VecX , class VecY >
VecX::value_type	dot_conj (const VecX &x, const VecY &y) MTL_THROW_ASSERTION
template<class LinalgObj , class T >
void	set (LinalgObj A, const T &alpha)
template<class Sequence1 , class Sequence2 , class Matrix , class MatrixP >
void	partition (const Sequence1 &prows, const Sequence2 &pcols, const Matrix &A, MatrixP &P) MTL_THROW_ASSERTION
template<class Scalable , class T >
Scalable::scaled_type	scaled (const Scalable &A, const T &alpha)
template<class RandomAccessContainerRef , class Distance >
strided1D < RandomAccessContainerRef >	strided (RandomAccessContainerRef v, Distance stride_)
template<class size_type >
dimension< size_type >	calc_start_fini (int i, int minor, dimension< size_type > bandwidth)
	noindex:
template<class Tag , class Collection >
traits::range_generator< Tag, Collection >::type	begin (Collection const &c)
	Returns begin cursor over the Collection or a subset of the Collection.
template<class Tag , class Collection >
traits::range_generator< Tag, Collection >::type	end (Collection const &c)
	Corresponding end cursor.
template<typename Collection >
void	swap (Collection &c1, Collection &c2)
	Free function defined for all matrix and vector types.
template<typename T >
boost::enable_if< is_clonable < T >, T >::type	clone (const T &x)
	Move-semantics-related anti-dot: always copy in constructor.
template<typename Value >
sfunctor::real< Value > ::result_type	real (const Value &v)
	real part of scalars (including non-complex)
template<typename Value >
sfunctor::imag< Value > ::result_type	imag (const Value &v)
	imaginary part of scalars (including non-complex)
template<typename Value >
sfunctor::signum< Value > ::result_type	signum (const Value &v)
	sign of scalars; for complex numbers sign of real part
template<typename MatrixSrc , typename MatrixDest >
void	matrix_copy (const MatrixSrc &src, MatrixDest &dest)
	Copy matrix `src` into matrix `dest`.
template<typename MatrixSrc , typename MatrixDest >
void	matrix_copy_plus (const MatrixSrc &src, MatrixDest &dest)
	Add matrix `src` to matrix `dest` in copy-like style.
template<typename MatrixSrc , typename MatrixDest >
void	matrix_copy_minus (const MatrixSrc &src, MatrixDest &dest)
	Subtract matrix `src` from matrix `dest` in copy-like style.
template<typename MatrixSrc , typename MatrixDest >
void	matrix_copy_ele_times (const MatrixSrc &src, MatrixDest &dest)
	Multiply matrix `src` element-wise with matrix `dest` in copy-like style.
template<typename VectorSrc , typename VectorDest >
void	vector_copy (const VectorSrc &src, VectorDest &dest)
	Copy vector `src` into vector `dest`.
template<typename VectorSrc , typename VectorDest >
void	vector_copy_plus (const VectorSrc &src, VectorDest &dest)
	Add vector `src` to vector `dest` in copy-like style.
template<typename VectorSrc , typename VectorDest >
void	vector_copy_minus (const VectorSrc &src, VectorDest &dest)
	Subtract vector `src` from vector `dest` in copy-like style.
template<typename Factor , typename Collection >
void	divide_by_inplace (Collection &c, const Factor &alpha, tag::scalar)
	Divide collection `c` (from right) by scalar factor `alpha`; `c` is altered.
template<typename Factor , typename Collection >
void	divide_by_inplace (Collection &c, const Factor &alpha)
	Divide collection `c` (from right) by factor `alpha`; `c` is altered.
template<typename Collection >
traits::num_cols< Collection > ::type	num_cols (const Collection &c)
	num_cols function for non-MTL types (uses implicit enable_if), 1D interpreted as Column vector
template<typename Collection >
traits::num_rows< Collection > ::type	num_rows (const Collection &c)
	num_rows function for non-MTL types (uses implicit enable_if), 1D interpreted as Column vector
template<unsigned long Unroll, typename Value >
Collection< Value >::value_type	product (const Value &value)
	Returns product of all collection-entries (vector-entries)
template<typename Factor , typename Collection >
void	right_scale_inplace (Collection &c, const Factor &alpha, tag::scalar)
	Scale collection `c` from right with scalar factor `alpha`; `c` is altered.
template<typename Factor , typename Collection >
void	right_scale_inplace (Collection &c, const Factor &alpha, tag::matrix)
	Scale collection `c` from right with matrix factor `alpha`; `c` is altered.
template<typename Factor , typename Collection >
void	right_scale_inplace (Collection &c, const Factor &alpha)
	Scale collection `c` from right with factor `alpha`; `c` is altered.
template<typename Collection >
traits::size< Collection >::type	size (const Collection &c)
	size function for non-MTL types (uses implicit enable_if)
template<typename Vector >
traits::size< Vector >::type	size1D (const Vector &v)
	One-dimensional size function.
template<typename T >
boost::enable_if < boost::mpl::or_ < boost::is_integral< T > , boost::is_floating_point< T > >, T >::type	squared_abs (const T &x)
	When squaring magnitudes of intrinsic types the abs can be omitted.
template<typename T >
T	squared_abs (const std::complex< T > &z)
	Squaring complex numbers can be computed without square root.
template<unsigned long Unroll, typename Value >
Collection< Value >::value_type	sum (const Value &value)
	Return sum of all vector-entries.
template<unsigned BSize, typename Coll >
mtl::traits::enable_if_vector < Coll, vector::unrolled1 < BSize, Coll > >::type	unroll (Coll &v)
	Helper function for customizing loop unrolling in expressions.
template<class Tag , class Coll >
traits::range_generator< Tag, Coll >::type	lower_bound (Coll const &c, typename Collection< Coll >::size_type position)
	Cursor to an element with index equal or larger than `position` in a one-dimensional traversion.
template<typename Value , typename Allocator >
void	shrink_stl_vector (std::vector< Value, Allocator > &v)
	Shrink memory consumption of an STL vector to its size.
template<typename EnumType , typename Array >
EnumType	string_to_enum (const std::string &s, const Array &l, EnumType)
Variables
const std::size_t	imax = std::numeric_limits<std::size_t>::max()
	Maximal index.

Detailed Description

Main name space for Matrix Template Library.

Function Documentation

template<class VecX , class VecY , class VecZ >

void mtl::add	(	const VecX &	x,
		const VecY &	y,
		MTL_OUT(VecZ)	z_
	)		`[inline]`

category: algorithms component: function definition: mtl.h example: y_ax_y.cc, vecvec_add.cc typereqs: VecX::value_type, VecY::value_type, and VecZ::value_type should be the same type typereqs: The addition operator must be defined for the value_type. complexity: linear time

template<class VecW , class VecX , class VecY , class VecZ >

void mtl::add	(	const VecX &	x,
		const VecY &	y,
		const VecZ &	z,
		MTL_OUT(VecW)	w_
	)		`[inline]`

category: algorithms component: function definition: mtl.h example: vecvec_add3.cc typereqs: VecX::value_type, VecY::value_type, VecZ::value_type, and VecW::value_type should be the same type typereqs: The addition operator must be defined for the value_type. complexity: linear time

template<class LinalgA , class LinalgB >

void mtl::add	(	const LinalgA &	A,
		MTL_OUT(LinalgB)	B_
	)		`[inline]`

category: algorithms component: function definition: mtl.h complexity: O(m*n) for a dense A, O(nnz) for a sparse A. O(n) for a vector.

template<class Tag , class Collection >

traits::range_generator< Tag, Collection >::type mtl::begin ( Collection const & c ) [inline]

Returns begin cursor over the Collection or a subset of the Collection.

Form of traversal depends on Tag, cf utility/glas_tag.hpp On nested traversals, cursors of level > 1 must provide at least one range generator

template<class Matrix >

block_view< Matrix, 0, 0 >::type mtl::blocked	(	const Matrix &	A,
		int	bm,
		int	bn
	)

category: containers component: function example: blocked_matrix.cc definition: matrix.h tparam: Matrix - The type of the Matrix to be blocked, must be dense

template<class Matrix , int BM, int BN>

block_view< Matrix, BM, BN >::type mtl::blocked	(	const Matrix &	A,
		blk< BM, BN >
	)

category: containers component: function example: blocked_matrix.cc definition: matrix.h tparam: Matrix - The type of the Matrix to be blocked, must be dense tparam: BM - The blocking factor for the rows (M dimension) tparam: BN - The blocking factor for the columns (N dimension)

template<typename T >

boost::disable_if< is_clonable< T >, T >::type mtl::clone ( const T & x )

Move-semantics-related anti-dot: always copy in constructor.

Some collections have referring semantics in copy constructors, e.g. sub-matrices. That means

        Matrix B= sub_matrix(A, ...);

creates a sub-matrix of A in B. As a consequence, changes in B modify A and vice versa (unless it's outside the sub-matrix). In contrast, clone forces the copy semantics

        Matrix B= clone(sub_matrix(A, ...));

B now contains the values of A's sub-matrix but is an independent matrix. Modifications to either A or B have no effect to each other. Requires that type T is declared clonable in terms of

        is_clonable<T> : boost::mpl::true_ {};

template<class Matrix >

columns_type< Matrix >::type mtl::columns ( const Matrix & A ) [inline]

component: function category: containers tparam: Matrix - The Matrix to access column-wise. Matrix must be dense.

template<class LinalgA , class LinalgB >

void mtl::copy	(	const LinalgA &	A,
		MTL_OUT(LinalgB)	B_
	)		`[inline]`

category: algorithms component: function definition: mtl.h complexity: O(m*n) for matrices. O(nnz) if either A or B are sparse and of the same orientation (otherwise it can be O(nnz^2). O(n) for vectors. example: vecvec_copy.cc

template<class VecX , class VecY , class T >

T mtl::dot	(	const VecX &	x,
		const VecY &	y,
		T	s
	)		`[inline]`

category: algorithms component: function definition: mtl.h

template<class VecX , class VecY >

VecX::value_type mtl::dot	(	const VecX &	x,
		const VecY &	y
	)		`[inline]`

category: algorithms component: function example: vecvec_dot.cc, dot_prod.cc definition: mtl.h

template<class VecX , class VecY , class T >

T mtl::dot_conj	(	const VecX &	x,
		const VecY &	y,
		T	s
	)		`[inline]`

category: algorithms component: function definition: mtl.h

template<class VecX , class VecY >

VecX::value_type mtl::dot_conj	(	const VecX &	x,
		const VecY &	y
	)		`[inline]`

category: algorithms component: function definition: mtl.h

template<class VecX , class VecY , class VecZ >

void mtl::ele_div	(	const VecX &	x,
		const VecY &	y,
		MTL_OUT(VecZ)	z_
	)		`[inline]`

category: algorithms component: function definition: mtl.h example: vecvec_ele_div.cc

template<class VecX , class VecY , class VecZ >

void mtl::ele_mult	(	const VecX &	x,
		const VecY &	y,
		MTL_OUT(VecZ)	z_
	)		`[inline]`

category: algorithms component: function definition: mtl.h example: vecvec_ele_mult.cc

template<class MatA , class MatB >

void mtl::ele_mult	(	const MatA &	A,
		MTL_OUT(MatB)	B_
	)		`[inline]`

category: algorithms component: function definition: mtl.h complexity: O(n^2)

template<class VecX , class VecY >

void mtl::gather	(	const VecX &	x,
		MTL_OUT(VecY)	y_
	)		`[inline]`

category: algorithms component: function definition: mtl.h complexity: O(n) where n is the size of the sparse vector

template<class LinalgObj >

linalg_traits< LinalgObj >::magnitude_type mtl::infinity_norm ( const LinalgObj & A ) [inline]

category: algorithms component: function definition: mtl.h complexity: O(n) for vectors, O(m*n) for dense matrices, O(nnz) for sparse example: vec_inf_norm.cc typereqs: The vector or matrix must have an associated magnitude_type that is the type of the absolute value of its value_type. typereqs: There must be abs() defined for Vector::value_type. typereqs: The addition must be defined for magnitude_type.

template<class Tag , class Coll >

traits::range_generator<Tag, Coll>::type mtl::lower_bound	(	Coll const &	c,
		typename Collection< Coll >::size_type	position
	)		`[inline]`

Cursor to an element with index equal or larger than position in a one-dimensional traversion.

This function is only defined where Tag represents an obvious one-dimensional traversion of Collection allowing for an interpretation of position. Examples are tag::row for a dense matrix or row-major compressed matrix. tag::all regarding an entire matrix (i.e. going over all entries of a matrix) does not characterize a one-dimensional traversion so that position has no unique meaning. Traversing all entries of a matrix row is one-dimensional and position is understood as looking for a column index, i.e. lower_bound<tag::all>(row_cursor, 7) returns a cursor to a matrix element whose row is the one of row_cursor and whose column is 7. Likewise traversing all non-zeros of a row will return a cursor that points to an entry with according row index and column index at least 7. If the searched index could not be found in the one-dimensional collection the returned cursor will be identical to the one returned by the end function.

template<class DenseMatrix , class Pvector >

int mtl::lu_factor	(	DenseMatrix &	A,
		Pvector &	ipvt
	)

tparam: DenseMatrix - A dense MTL Matrix tparam: Pvector - A Vector with integral element type category: algorithms component: function example: lu_factorization.cc

template<class DenseMatrixLU , class DenseMatrix , class Pvector >

void mtl::lu_inverse	(	const DenseMatrixLU &	LU,
		const Pvector &	pvector,
		DenseMatrix &	AInv
	)

tparam: DenseMatrixLU - A dense MTL Matrix which resulted from calling lu_factor tparam: DenseMatrix = The dense Matrix type used to store the inverse tparam: Pvector - A Vector with integral element type, the ipvt vector from lu_factor category: algorithms component: function

template<class DenseMatrix , class VectorB , class VectorX , class Pvector >

void mtl::lu_solve	(	const DenseMatrix &	LU,
		const Pvector &	pvector,
		const VectorB &	b,
		VectorX &	x
	)

tparam: DenseMatrix - A dense MTL Matrix which resulted from calling lu_factor tparam: Pvector - A Vector with integral element type, the ipvt vector from lu_factor category: algorithms component: function example: lu_solve.cc

template<class VectorT >

VectorT::value_type mtl::max ( const VectorT & x ) [inline]

category: algorithms component: function definition: mtl.h example: vec_max.cc complexity: O(n) typereqs: Vec::value_type must be LessThanComparible.

template<class Vec >

Vec::size_type mtl::max_abs_index ( const Vec & x ) [inline]

category: algorithms component: function definition: mtl.h complexity: O(n) example: max_abs_index.cc typereqs: The vector or matrix must have an associated magnitude_type that typereqs: There must be abs() defined for Vector::value_type. typereqs: The magnitude type must be LessThanComparible.

template<class Vec >

Vec::size_type mtl::max_index ( const Vec & x ) [inline]

category: algorithms component: function definition: mtl.h complexity: O(n) example: max_index.cc typereqs: Vec::value_type must be LessThanComparible.

template<class VectorT >

VectorT::value_type mtl::min ( const VectorT & x ) [inline]

category: algorithms component: function complexity: O(n) definition: mtl.h typereqs: Vec::value_type must be LessThanComparible.

template<class Vec >

Vec::size_type mtl::min_abs_index ( const Vec & x ) [inline]

category: algorithms component: function definition: mtl.h complexity: O(n) example: max_index.cc typereqs: The vector or matrix must have an associated magnitude_type that typereqs: There must be abs() defined for Vector::value_type. typereqs: The magnitude type must be LessThanComparible.

template<class Vec >

Vec::size_type mtl::min_index ( const Vec & x ) [inline]

category: algorithms component: function definition: mtl.h complexity: O(n) example: min_abs_index.cc typereqs: Vec::value_type must be LessThanComparible.

template<class Matrix , class VecX , class VecY , class VecZ >

void mtl::mult	(	const Matrix &	A,
		const VecX &	x,
		const VecY &	y,
		MTL_OUT(VecZ)	z_
	)		`[inline]`

category: algorithms component: function definition: mtl.h precond: A.nrows() <= y.size() precond: A.nrows() <= z.size() precond: A.ncols() <= x.size() precond: no aliasing in the arguments example: symm_sparse_vec_prod.cc typereqs: Matrix::value_type, VecX::value_type, VecY::value_type, and VecZ::value_type must be the same type typereqs: the multiplication operator must be defined for Matrix::value_type typereqs: the addition operator must be defined for Matrix::value_type

template<class Matrix , class VecX , class VecY >

void mtl::mult_dim__	(	const Matrix &	A,
		const VecX &	x,
		VecY &	y,
		oned_tag
	)		`[inline]`

category: algorithms component: function definition: mtl.h example: general_matvec_mult.cc, banded_matvec_mult.cc, symm_matvec_mult.cc precond: A.nrows() <= y.size() precond: A.ncols() <= x.size() precond: x and y not same vector example: symm_matvec_mult.cc typereqs: Matrix::value_type, VecX::value_type, and VecY::value_type must be the same type typereqs: the multiplication operator must be defined for Matrix::value_type typereqs: the addition operator must be defined for Matrix::value_type

template<class MatA , class MatB , class MatC >

void mtl::mult_dim__	(	const MatA &	A,
		const MatB &	B,
		MatC &	C,
		twod_tag
	)		`[inline]`

precond: A.nrows() == C.nrows() precond: A.ncols() == B.nrows() precond: B.ncols() == C.ncols() category: algorithms component: function definition: mtl.h typereqs: the value types for each of the matrices must be compatible typereqs: the multiplication operator must be defined for MatA::value_type typereqs: the addition operator must be defined for MatA::value_type

template<class LinalgObj >

linalg_traits< LinalgObj >::magnitude_type mtl::one_norm ( const LinalgObj & A ) [inline]

category: algorithms component: function definition: mtl.h example: vec_one_norm.cc complexity: O(n) typereqs: The vector or matrix must have an associated magnitude_type that typereqs: There must be abs() defined for Vector::value_type. typereqs: The addition must be defined for magnitude_type.

template<class Sequence1 , class Sequence2 , class Matrix , class MatrixP >

void mtl::partition	(	const Sequence1 &	prows,
		const Sequence2 &	pcols,
		const Matrix &	A,
		MatrixP &	P
	)		`[inline]`

category: algorithms component: function typereqs: The element type for matrix P should be the same as the submatrix_type of matrix A. complexity: O(P.nrows() * P.ncols()) example: partition.cc

template<class Matrix , class VecX , class VecY >

void mtl::rank_one_update	(	MTL_OUT(Matrix)	A_,
		const VecX &	x,
		const VecY &	y
	)		`[inline]`

precond: A.nrows() <= x.size() precond: A.ncols() <= y.size() precond: A has rectangle shape and is dense category: algorithms component: function definition: mtl.h example: rank_one.cc typereqs: Matrix::value_type, VecX::value_type, and VecY::value_type must be the same type typereqs: the multiplication operator must be defined for Matrix::value_type typereqs: the addition operator must be defined for Matrix::value_type

template<class Matrix , class VecX , class VecY >

void mtl::rank_two_update	(	MTL_OUT(Matrix)	A_,
		const VecX &	x,
		const VecY &	y
	)		`[inline]`

category: algorithms component: function precond: A.nrows() == A.ncols() precond: A.nrows() == x.size() precond: x.size() == y.size() precond: A has rectangle shape and is dense. definition: mtl.h example: rank_2_symm_sparse.cc typereqs: Matrix::value_type, VecX::value_type, and VecY::value_type must be the same type. typereqs: The multiplication operator must be defined for Matrix::value_type. typereqs: The addition operator must be defined for Matrix::value_type.

void mtl::read_dense_matlab	(	matlab_dense &	A,
		char *	matrix_name,
		const char *	file
	)		`[inline]`

category: utilities component: function

void mtl::read_sparse_matlab	(	matlab_sparse &	A,
		char *	matrix_name,
		const char *	file
	)		`[inline]`

category: utilities component: function

template<class Matrix >

rows_type< Matrix >::type mtl::rows ( const Matrix & A ) [inline]

example: swap_rows.cc component: function category: containers tparam: Matrix - The Matrix to access row-wise. Matrix must be dense.

template<class LinalgObj , class T >

void mtl::scale	(	MTL_OUT(LinalgObj)	A,
		const T &	alpha
	)		`[inline]`

category: algorithms component: function example: vec_scale_algo.cc complexity: O(n) definition: mtl.h typereqs: Vector must be mutable typereqs: T is convertible to Vector's value_type typereqs: The multiplication operator must be defined for Vector::value_type and T

template<class Scalable , class T >

Scalable::scaled_type mtl::scaled	(	const Scalable &	A,
		const T &	alpha
	)		`[inline]`

category: containers component: function definition: scaled1D.h typereqs: T must be convertible to Scalable's value_type typereqs: Scalable's value_type must be a model of Ring complexity: compile time and adds a single multiplication complexity: to each element access inside of any algorithm example: y_ax_y.cc

template<class VecX , class VecY >

void mtl::scatter	(	const VecX &	x,
		MTL_OUT(VecY)	y_
	)		`[inline]`

category: algorithms component: function definition: mtl.h complexity: O(n) where n is the size of the sparse vector

template<class LinalgObj , class T >

void mtl::set	(	LinalgObj	A,
		const T &	alpha
	)		`[inline]`

category: algorithms component: function definition: mtl.h example: vec_set.cc complexity: O(m*n) for dense matrix, O(nnz) for sparse, O(n) for vector typereqs: Vector must be mutable typereqs: T is convertible to Vector's value_type

template<class Matrix , class T >

void mtl::set_diagonal	(	MTL_OUT(Matrix)	A_,
		const T &	alpha
	)		`[inline]`

category: algorithms component: function definition: mtl.h example: tri_pack_sol.cc typereqs: T must be convertible to Matrix::value_type. complexity: O(min(m,n)) for dense matrices, O(nnz) for sparse matrices (except envelope, which is O(m))

template<typename Vector >

traits::size<Vector>::type mtl::size1D ( const Vector & v ) [inline]

One-dimensional size function.

Returns size for MTL vectors, STL vector and C arrays. For multi_vector the number of vectors is returned. Not defined for other matrix types. Implementation for standard types uses implicit enable_if to avoid ambiguities.

template<class RandomAccessContainerRef , class Distance >

strided1D< RandomAccessContainerRef > mtl::strided	(	RandomAccessContainerRef	v,
		Distance	stride_
	)		`[inline]`

category: containers component: function definition: strided1D.h typereqs: Distance must be compatible with RandomAccessContainerRef's Distance complexity: compile time

template<typename EnumType , typename Array >

EnumType mtl::string_to_enum	(	const std::string &	s,
		const Array &	l,
		EnumType
	)		`[inline]`

Searches string s in list l of strings and returns enum

List l is given as array of const char*, which is the easiest to initialize. The search is case sensitive, thus (de)-capitalize your string upfront, e.g., with boost::to_lower(). If the string is not found then a runtime_error is thrown.

template<class Vector >

linalg_traits< Vector >::value_type mtl::sum ( const Vector & x ) [inline]

category: algorithms component: function definition: mtl.h example: vec_sum.cc complexity: linear typereqs: The addition operator must be defined for Vector::value_type.

template<class Vector >

linalg_traits< Vector >::value_type mtl::sum_squares ( const Vector & x ) [inline]

category: algorithms component: function definition: mtl.h complexity: O(n)

template<class LinalgA , class LinalgB >

void mtl::swap	(	MTL_OUT(LinalgA)	A,
		MTL_OUT(LinalgB)	B
	)		`[inline]`

category: algorithms component: function definition: mtl.h complexity: O(n^2) example: vecvec_swap.cc

template<class Matrix >

Matrix::transpose_type mtl::trans ( const Matrix & A ) [inline]

component: function category: containers tparam: Matrix - The Matrix to transpose example: trans_mult.cc

template<class Matrix >

void mtl::transpose ( MTL_OUT(Matrix) A_ ) [inline]

category: algorithms component: function definition: mtl.h

template<class MatA , class MatB >

void mtl::transpose	(	const MatA &	A,
		MTL_OUT(MatB)	B_
	)		`[inline]`

precond: B(i,j) = 0 & B = A^T

category: algorithms component: function definition: mtl.h complexity: O(n^2)

template<class TriMatrix , class VecX >

void mtl::tri_solve	(	const TriMatrix &	T,
		MTL_OUT(VecX)	x_
	)		`[inline]`

category: algorithms component: function definition: mtl.h example: tri_solve.cc typereqs: Matrix::value_type and VecX::value_type must be the same type typereqs: the multiplication operator must be defined for Matrix::value_type typereqs: the division operator must be defined for Matrix::value_type typereqs: the addition operator must be defined for Matrix::value_type

template<class MatT , class MatB , class Side >

void mtl::tri_solve	(	const MatT &	T,
		MTL_OUT(MatB)	B,
		Side	s
	)		`[inline]`

category: algorithms component: function definition: mtl.h complexity: O(n^3) example: matmat_trisolve.cc typereqs: MatT::value_type and MatB::value_type must be the same type typereqs: the multiplication operator must be defined for MatT::value_type typereqs: the division operator must be defined for MatT::value_type typereqs: the addition operator must be defined for MatT::value_type

template<class Vector >

linalg_traits< Vector >::magnitude_type mtl::two_norm ( const Vector & x ) [inline]

category: algorithms component: function definition: mtl.h example: vec_two_norm.cc complexity: O(n) typereqs: Vector must have an associated magnitude_type that is the type of the absolute value of Vector::value_type. typereqs: There must be abs() defined for Vector::value_type. typereqs: The addition must be defined for magnitude_type. typereqs: sqrt() must be defined for magnitude_type.

template<unsigned BSize, typename Coll >

mtl::traits::enable_if_vector<Coll, vector::unrolled1<BSize, Coll> >::type mtl::unroll ( Coll & v ) [inline]

Helper function for customizing loop unrolling in expressions.

For instance,

      unroll<6>(u)= v + 3. * w;

will unroll the loop that computes

      u= v + 3. * w;

with block size 6.

void mtl::write_dense_matlab	(	matlab_dense &	A,
		char *	matrix_name,
		const char *	file
	)		`[inline]`

category: utilities component: function

void mtl::write_sparse_matlab	(	matlab_sparse &	A,
		char *	matrix_name,
		const char *	file
	)		`[inline]`

category: utilities component: function

Namespaces

Classes

Functions

Variables

Detailed Description

Function Documentation