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> | |
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: | |
Variables | |
const std::size_t | imax = std::numeric_limits<std::size_t>::max() |
Maximal index. |
void mtl::add | ( | const LinalgA & | A, | |
MTL_OUT(LinalgB) | B_ | |||
) | [inline] |
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
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
block_view<Matrix, BM, BN>::type mtl::blocked | ( | const Matrix & | A, | |
blk< BM, BN > | ||||
) | [inline] |
block_view<Matrix, 0, 0>::type mtl::blocked | ( | const Matrix & | A, | |
int | bm, | |||
int | bn | |||
) | [inline] |
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, ...);
Matrix B= clone(sub_matrix(A, ...));
is_clonable<T> : boost::mpl::true_ {};
columns_type<Matrix>::type mtl::columns | ( | const Matrix & | A | ) | [inline] |
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
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
T mtl::dot | ( | const VecX & | x, | |
const VecY & | y, | |||
T | s | |||
) | [inline] |
category: algorithms component: function definition: mtl.h
VecX::value_type mtl::dot_conj | ( | const VecX & | x, | |
const VecY & | y | |||
) | [inline] |
category: algorithms component: function definition: mtl.h
T mtl::dot_conj | ( | const VecX & | x, | |
const VecY & | y, | |||
T | s | |||
) | [inline] |
category: algorithms component: function definition: mtl.h
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
void mtl::ele_mult | ( | const MatA & | A, | |
MTL_OUT(MatB) | B_ | |||
) | [inline] |
category: algorithms component: function definition: mtl.h complexity: O(n^2)
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
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
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.
int mtl::lu_factor | ( | DenseMatrix & | A, | |
Pvector & | ipvt | |||
) | [inline] |
void mtl::lu_inverse | ( | const DenseMatrixLU & | LU, | |
const Pvector & | pvector, | |||
DenseMatrix & | AInv | |||
) | [inline] |
void mtl::lu_solve | ( | const DenseMatrix & | LU, | |
const Pvector & | pvector, | |||
const VectorB & | b, | |||
VectorX & | x | |||
) | [inline] |
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.
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.
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.
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.
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.
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.
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
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
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
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.
void mtl::partition | ( | const Sequence1 & | prows, | |
const Sequence2 & | pcols, | |||
const Matrix & | A, | |||
MatrixP & | P | |||
) | [inline] |
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
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
rows_type<Matrix>::type mtl::rows | ( | const Matrix & | A | ) | [inline] |
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
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
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
void mtl::set | ( | LinalgObj | A, | |
const T & | alpha | |||
) | [inline] |
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))
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
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.
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
.
linalg_traits<Vector>::value_type mtl::sum_squares | ( | const Vector & | x | ) | [inline] |
category: algorithms component: function definition: mtl.h complexity: O(n)
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
Matrix::transpose_type mtl::trans | ( | const Matrix & | A | ) | [inline] |
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)
void mtl::transpose | ( | MTL_OUT(Matrix) | A_ | ) | [inline] |
category: algorithms component: function definition: mtl.h
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
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
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.