mtl Namespace Reference

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


Classes

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  mtl::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...
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  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  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  missing_diagonal
 Exception for arguments with incompatible sizes. 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...
class  irange
 Class to define a half open index ranges. 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...
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  mtl::givens_rotation< std::complex< double > >
class  mtl::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...

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

Functions

template<typename Collection>
void swap (Collection &c1, Collection &c2)
 Free function defined for all matrix and vector types.
template<typename Collection, typename Functor>
void assign_each_nonzero (Collection &c, const Functor &f)
 Assign f(i) to each non-zero i in collection c.
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 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<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 EnumType, typename Array>
EnumType string_to_enum (const std::string &s, const Array &l, EnumType)
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:

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 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 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 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 Matrix, int BM, int BN>
block_view<Matrix, BM, BN>::type mtl::blocked ( const Matrix &  A,
blk< BM, BN >   
) [inline]

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<class Matrix>
block_view<Matrix, 0, 0>::type mtl::blocked ( const Matrix &  A,
int  bm,
int  bn 
) [inline]

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<typename T>
boost::disable_if< is_clonable< T >, T >::type mtl::clone ( const T &  x  )  [inline]

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>
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 ( 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 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, 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 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, 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 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 DenseMatrix, class Pvector>
int mtl::lu_factor ( DenseMatrix &  A,
Pvector &  ipvt 
) [inline]

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 
) [inline]

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 
) [inline]

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 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 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 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<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 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 Matrix>
void mtl::transpose ( MTL_OUT(Matrix)  A_  )  [inline]

category: algorithms component: function definition: mtl.h

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

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 -- Generated on 19 May 2009 by Doxygen 1.5.5 -- Copyright 2007 by the Trustees of Indiana University.