Logo MTL4
Namespaces | Classes | Functions | Variables
mtl Namespace Reference

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 >
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 >
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 >
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,
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,
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


mtl Namespace Reference -- MTL 4 -- Peter Gottschling and Andrew Lumsdaine -- Gen. with rev. 7542 on Sat Aug 11 2012 by doxygen 1.7.6.1 -- © 2010 by SimuNova UG.