Logo MTL4
mtl::matrix

mtl::matrix Namespace Reference

Namespace for matrices and views and operations exclusively on matrices. More...


Classes

struct  base_matrix
 Base class for other matrices, contains only very simple functionality that is used in all matrices. More...
class  compressed2D
 Compressed 2D matrix type. More...
struct  crtp_assign< mat_mat_plus_expr< E1, E2 >, Matrix >
 Assign sum by assigning first argument and adding second. More...
struct  crtp_assign< mat_mat_minus_expr< E1, E2 >, Matrix >
 Assign difference by assigning first argument and subtracting second. More...
struct  crtp_assign< mat_mat_times_expr< E1, E2 >, Matrix >
 Assign product by calling mult. More...
struct  crtp_assign< mat_mat_ele_times_expr< E1, E2 >, Matrix >
 Assign element-wise product. More...
struct  crtp_assign< Value[Rows][Cols], Matrix >
 Assign c-style 2D-array, because it's easier to initialize. More...
struct  crtp_plus_assign
 Assign-add matrix expressions by incrementally copying except for some special expressions. More...
struct  crtp_plus_assign< mat_mat_plus_expr< E1, E2 >, Matrix >
 Assign-add sum by adding both arguments. More...
struct  crtp_minus_assign
 Assign-subtract matrix expressions by decrementally copying except for some special expressions. More...
struct  crtp_minus_assign< mat_mat_plus_expr< E1, E2 >, Matrix >
 Assign-subtract sum by adding both arguments. More...
struct  crtp_minus_assign< mat_mat_minus_expr< E1, E2 >, Matrix >
 Assign-subtracting difference by subtracting first argument and adding the second one. More...
struct  crtp_minus_assign< mat_mat_times_expr< E1, E2 >, Matrix >
 Assign-subtract product by calling gen_mult. More...
struct  crtp_matrix_assign
 Base class to provide matrix assignment operators generically. More...
struct  mat_expr
 Base class for CRTP with matrices. More...
struct  dmat_expr
 Base class for CRTP with dense matrices. More...
struct  smat_expr
 Base class for CRTP with sparse matrices. More...
class  multi_vector
 Matrix constituting of set of column vectors (under development). More...
struct  parameters
 Type for bundling template parameters of common matrix types. More...
class  givens
 Given's transformator. More...
struct  recursator
struct  crtp_assign< io::matrix_file< IFStream, OFStream >, Matrix >
 Assign content of a file to the matrix. More...

Functions

template<typename Matrix, typename Value>
void diagonal_setup (Matrix &matrix, const Value &value)
 Setup a matrix to a multiple of the unity matrix.
template<typename Matrix, typename Value>
void hessian_setup (Matrix &matrix, Value factor)
 Fills a matrix A with a_ij = factor * (i + j).
template<typename Matrix>
void laplacian_setup (Matrix &matrix, unsigned m, unsigned n)
 Setup a matrix according to a Laplacian equation on a 2D-grid using a five-point-stencil.
template<typename Matrix>
traits::lower< Matrix >::type lower (const Matrix &A)
 Lower triangular matrix.
template<typename Value, typename PermutationVector>
traits::permutation< Value
>::type 		permutation (const PermutationVector &v)
 Computes permutation matrix from corresponding vector.
template<typename Value, typename ReorderVector>
traits::reorder< Value >::type reorder (const ReorderVector &v, std::size_t cols=0)
 Computes reordering matrix from corresponding vector.
template<typename Matrix>
traits::strict_lower< Matrix
>::type 		strict_lower (const Matrix &A)
 Strict lower triangular matrix.
template<typename Matrix>
traits::strict_lower< Matrix
>::type 		tril (const Matrix &A, long d=0)
 Triangle-lower starting at off-diagonoal d (for compatibility with matlib).
template<typename Matrix>
traits::strict_upper< Matrix
>::type 		strict_upper (const Matrix &A)
 Strict upper triangle matrix.
template<typename Matrix>
traits::strict_upper< Matrix
>::type 		triu (const Matrix &A, long d=0)
 Triangle-upper starting at off-diagonoal d (for compatibility with matlib).
template<typename Matrix>
traits::upper< Matrix >::type upper (const Matrix &A)
 Upper triangular matrix.
template<typename LinOp>
traits::adjoint< LinOp >::type adjoint (const LinOp &A)
 Adjoint linear operator, typically Hermitian transposed.
template<typename Matrix>
mtl::traits::enable_if_matrix<
Matrix, conj_view< Matrix
> >::type 		conj (const Matrix &v)
 Conjugate of a matrix.
template<typename T>
mtl::traits::enable_if_matrix<
T, T & >::type 		crop (T &x)
 Remove all zero entries from a collection.
template<typename Matrix>
dense_vector< typename Collection<
Matrix >::value_type > 		diagonal (const Matrix &A)
 Return the vector with the diagonal of the matrix.
template<typename Matrix>
dense_vector< typename Collection<
Matrix >::value_type > 		qr_sym_imp (const Matrix &A)
 Eigenvalues of symmetric matrix A with implicit QR algorithm.
template<typename Matrix>
dense_vector< typename Collection<
Matrix >::value_type > 		qr_algo (const Matrix &A, typename Collection< Matrix >::size_type itMax)
 Evaluation of eigenvalues with QR-Algorithm of matrix A.
template<typename Matrix>
dense_vector< typename Collection<
Matrix >::value_type > 		eigenvalue_symmetric (const Matrix &A, typename Collection< Matrix >::size_type itMax=0)
 Calculation of eigenvalues of symmetric matrix A.
template<typename Matrix>
RealMagnitude< typename Collection<
Matrix >::value_type >::type 		frobenius_norm (const Matrix &matrix)
 Frobenius norm, i.e. square root of sum of squares of all entries sqrt(sum_i sum_j(|a[i][j]|^2)).
template<typename Matrix>
mtl::traits::enable_if_matrix<
Matrix, hermitian_view< Matrix
> >::type 		hermitian (const Matrix &matrix)
 Returns hermitian view of matrix A.
template<typename Matrix>
Matrix hessenberg_factors (const Matrix &A)
 Hessenberg-Factorization of matrix A with householder-vectors.
template<typename Matrix>
Matrix extract_householder_hessenberg (const Matrix &H)
 Extract Householder vectors from Hessenberg factorization H of some A.
template<typename Matrix>
Matrix householder_hessenberg (const Matrix &A)
 Compute Householder vectors from Hessenberg factorization of A.
template<typename Matrix>
Matrix extract_hessenberg (const Matrix &H)
 Extract Hessenberg form from factorization H of some A.
template<typename Matrix>
Matrix hessenberg (const Matrix &A)
 Hessenberg form of A.
template<typename Matrix>
Matrix hessenberg_q (const Matrix &A)
 Return Q where Q'*A*Q == hessenberg(A).
template<unsigned long Unroll, typename Matrix>
mtl::traits::enable_if_matrix<
Matrix, typename RealMagnitude<
typename Collection< Matrix
>::value_type >::type >::type 		infinity_norm (const Matrix &matrix)
template<typename Matrix>
traits::inv< Matrix >::type inv_upper (Matrix const &A)
 Invert upper triangular matrix.
template<typename Matrix>
traits::inv< Matrix >::type inv_lower (Matrix const &A)
 Invert lower triangular matrix.
template<typename Matrix>
traits::inv< Matrix >::type inv (Matrix const &A)
 Invert matrix.
template<typename Matrix>
void invert_diagonal (Matrix &matrix)
 Returns matrix with invert diagonal.
template<typename Factor, typename Matrix>
mtl::traits::enable_if_matrix<
Matrix, Matrix & >::type 		left_scale_inplace (const Factor &alpha, Matrix &A)
 Scale matrix c from left with scalar or matrix factor alpha; c is altered.
template<typename Matrix, typename Vector>
Vector lower_trisolve (const Matrix &A, const Vector &v)
 Solves the lower triangular matrix A with the rhs v and returns the solution vector.
template<typename Matrix, typename Vector>
Vector unit_lower_trisolve (const Matrix &A, const Vector &v)
 Solves the lower triangular matrix A (only one's in the diagonal) with the rhs v and returns the solution vector.
template<typename Matrix, typename Vector>
Vector inverse_lower_trisolve (const Matrix &A, const Vector &v)
 Solves the lower triangular matrix A (inverse the diagonal) with the rhs v and returns the solution vector.
template<typename Matrix>
void lu (Matrix &LU)
 LU factorization in place (without pivoting and optimization so far).
template<typename Matrix, typename PermuationVector>
void lu (Matrix &A, PermuationVector &P)
 LU factorization in place (with pivoting and without optimization so far).
template<typename Matrix>
Matrix lu_f (const Matrix &A)
 LU factorization without factorization that returns the matrix.
template<typename Matrix, typename Vector>
Vector lu_solve_straight (const Matrix &A, const Vector &b)
 Solve Ax = b by LU factorization without pivoting; vector x is returned.
template<typename Matrix, typename PermVector, typename Vector>
Vector lu_apply (const Matrix &LU, const PermVector &P, const Vector &b)
 Apply the factorization L*U with permutation P on vector b to solve Ax = b.
template<typename Matrix, typename Vector>
Vector lu_solve (const Matrix &A, const Vector &b)
 Solve Ax = b by LU factorization with column pivoting; vector x is returned.
template<typename Matrix, typename PermVector, typename Vector>
Vector lu_adjoint_apply (const Matrix &LU, const PermVector &P, const Vector &b)
 Apply the factorization L*U with permutation P on vector b to solve adjoint(A)x = b.
template<typename Matrix, typename Vector>
Vector lu_adjoint_solve (const Matrix &A, const Vector &b)
 Solve adjoint(A)x = b by LU factorization with column pivoting; vector x is returned.
template<typename Matrix>
mtl::traits::enable_if_matrix<
Matrix, std::pair< typename
Collection< Matrix >::size_type,
typename Collection< Matrix
>::size_type > >::type 		max_abs_pos (const Matrix &A)
 Returns pair (row, col) from absolut maximal entry of matrix A.
template<typename Matrix>
std::pair< typename Collection<
Matrix >::size_type, typename
Collection< Matrix >::size_type > 		max_pos (const Matrix &A)
 Returns pair (row, col) from maximal entry of matrix A.
template<typename A, typename B, typename C>
mtl::traits::enable_if_matrix<
A >::type 		mult (const A &a, const B &b, C &c)
 Multiplication: mult(a, b, c) computes c= a * b;.
template<typename A, typename B, typename C>
mtl::traits::enable_if_matrix<
A >::type 		mult_add (const A &a, const B &b, C &c)
 Multiplication: mult_add(a, b, c) computes c+= a * b;.
template<typename A, typename X, typename Y, typename Z>
void mult (const A &a, const X &x, const Y &y, Z &z)
 Four term multiplication: mult(a, x, y, z) computes z= a * x + y;.
template<typename MatrixA, typename MatrixB, typename MatrixC, typename Assign>
void mat_mat_mult (const MatrixA &a, const MatrixB &b, MatrixC &c, Assign, tag::dense, tag::dense, tag::dense)
 Dense matrix multiplication.
template<typename MatrixA, typename MatrixB, typename MatrixC, typename Assign>
void mat_mat_mult (const MatrixA &a, const MatrixB &b, MatrixC &c, Assign, tag::sparse, tag::sparse, tag::sparse)
 Sparse matrix multiplication.
template<typename MatrixA, typename MatrixB, typename MatrixC, typename Assign>
void mat_mat_mult (const MatrixA &a, const MatrixB &b, MatrixC &c, Assign, tag::sparse, tag::dense, tag::dense)
 Product of sparse times dense matrix.
template<unsigned long Unroll, typename Matrix>
mtl::traits::enable_if_matrix<
Matrix, typename RealMagnitude<
typename Collection< Matrix
>::value_type >::type >::type 		one_norm (const Matrix &matrix)
template<typename Op1, typename Op2>
mtl::traits::mult_result<
Op1, Op2 >::type 		operator * (const Op1 &op1, const Op2 &op2)
 Multiplication for all supported types of operations.
template<typename Op1, typename Op2>
mtl::traits::div_result< Op1,
Op2 >::type 		operator/ (const Op1 &op1, const Op2 &op2)
 Division of matrices and vectors by salars.
template<typename Matrix, typename VectorX, typename VectorY>
void rank_one_update (Matrix &matrix, const VectorX &x, const VectorY &y)
 Rank-one update: rank_one_update(A, x, y) computes A+= x * conj(y)^T.
template<typename Matrix, typename VectorX, typename VectorY>
void rank_two_update (Matrix &matrix, const VectorX &x, const VectorY &y)
 Rank-two update: rank_two_update(A, x, y) computes A+= x * conj(y)^T + y * conj(x)^T.
template<typename Coll>
mtl::traits::enable_if_matrix<
Coll >::type 		set_to_zero (Coll &collection)
template<typename Matrix>
sub_matrix_t< Matrix >::sub_matrix_type sub_matrix (Matrix &matrix, typename sub_matrix_t< Matrix >::size_type begin_row, typename sub_matrix_t< Matrix >::size_type end_row, typename sub_matrix_t< Matrix >::size_type begin_col, typename sub_matrix_t< Matrix >::size_type end_col)
 Returns sub-matrix B with begin_row, end_row, begin_col, end_col from matrix A.
template<typename Matrix>
mtl::traits::enable_if_matrix<
Matrix >::type 		swap_row (Matrix &A, typename Collection< Matrix >::size_type i, typename Collection< Matrix >::size_type j)
 Row i and j are swapped in matrix A.
template<typename Matrix, typename Vector>
Vector upper_trisolve (const Matrix &A, const Vector &v)
 Solves the upper triangular matrix A with the rhs v and returns the solution vector.
template<typename Matrix, typename Vector>
Vector unit_upper_trisolve (const Matrix &A, const Vector &v)
 Solves the upper triangular matrix A (only one's in the diagonal) with the rhs v and returns the solution vector.
template<typename Matrix, typename Vector>
Vector inverse_upper_trisolve (const Matrix &A, const Vector &v)
 Solves the upper triangular matrix A (inverse the diagonal) with the rhs v and returns the solution vector.
template<typename Matrix, typename Vector, typename DiaTag>
Vector upper_trisolve (const Matrix &A, const Vector &v, DiaTag)
 Solves the upper triangular matrix A with the rhs v and returns the solution vector.
template<typename Matrix>
recursator< Matrix > north_west (const recursator< Matrix > &rec)
template<typename Matrix>
recursator< Matrix > north_east (const recursator< Matrix > &rec)
template<typename Matrix>
recursator< Matrix > south_west (const recursator< Matrix > &rec)
template<typename Matrix>
recursator< Matrix > south_east (const recursator< Matrix > &rec)
template<typename Matrix>
bool is_empty (const recursator< Matrix > &rec)
template<typename Matrix>
bool is_full (const recursator< Matrix > &rec)
template<typename Matrix>
recursator< Matrix >::size_type num_rows (const recursator< Matrix > &rec)
template<typename Matrix>
recursator< Matrix >::size_type num_cols (const recursator< Matrix > &rec)
template<typename Matrix>
recursator< Matrix >::size_type size (const recursator< Matrix > &rec)

Variables

const std::size_t compressed_linear_search_limit = 10
 Maximal number of entries that is searched linearly; above this std::lower_bound is used.
const std::size_t dense_non_recursive_product_limit = 10000
 Maximal matrix size of dense matrices that is multiplied without recursion.
const std::size_t sorted_block_insertion_limit = 5
 Maximal number of columns in block that is inserted separately; above this the block is presorted (only row-major sparse matrices).

Detailed Description

Namespace for matrices and views and operations exclusively on matrices.

Function Documentation

template<typename T>
mtl::traits::enable_if_matrix<T, T&>::type mtl::matrix::crop ( T &  x  )  [inline]

Remove all zero entries from a collection.

Does nothing for dense collections

template<typename Matrix, typename Value>
void mtl::matrix::diagonal_setup ( Matrix &  matrix,
const Value &  value 
) [inline]

Setup a matrix to a multiple of the unity matrix.

Intended for sparse matrices but works also with dense matrices. If the value is 0 the matrix is only zeroed out, whereby a sparse matrix will be empty after this operation, i.e. the zeros on the diagonal are not explicitly stored. The diagonal in its generalized form is the set of entries with equal row and column index (since r6843, older revision considered it erroneous to store a non-zero scalar to a non-square matrix).

template<typename Matrix>
Matrix mtl::matrix::hessenberg_factors ( const Matrix &  A  )  [inline]

Hessenberg-Factorization of matrix A with householder-vectors.

Return Hessenberg matrix and tril(B,-2) are Householder-vectors

template<typename Matrix, typename Value>
void mtl::matrix::hessian_setup ( Matrix &  matrix,
Value  factor 
) [inline]

Fills a matrix A with a_ij = factor * (i + j).

Intended for dense matrices. Works on sparse matrices with inserter but is very expensive.

template<unsigned long Unroll, typename Matrix>
mtl::traits::enable_if_matrix< Matrix, typename RealMagnitude< typename Collection< Matrix >::value_type >::type >::type mtl::matrix::infinity_norm ( const Matrix &  matrix  )  [inline]

Infinity-norm for matrices: infinity_norm(x) $\rightarrow |x|_\infty$.

Return values:
The magnitude type of the respective value type, see Magnitude.
The norms are defined as $|A|_\infty=\max_i\{\sum_j(|A_{ij}|)\}$. Matrix norms are not (yet) optimized by unrolling.

template<typename Matrix>
traits::inv<Matrix>::type mtl::matrix::inv ( Matrix const &  A  )  [inline]

Invert matrix.

Uses pivoting LU factorization and triangular inversion

See also:
lu(A), inv_upper(A), inv_lower(A)

template<typename Matrix>
bool mtl::matrix::is_empty ( const recursator< Matrix > &  rec  )  [inline]

Check if a recursator (i.e. its referred matrix) is empty.

See also:
recursion intro

template<typename Matrix>
bool mtl::matrix::is_full ( const recursator< Matrix > &  rec  )  [inline]

Check if a recursator (i.e. its referred matrix) fills the entire block, i.e. if the number of rows and columns are both equal to the virtual bound.

See also:
recursion intro

template<typename Matrix>
void mtl::matrix::laplacian_setup ( Matrix &  matrix,
unsigned  m,
unsigned  n 
) [inline]

Setup a matrix according to a Laplacian equation on a 2D-grid using a five-point-stencil.

Intended for sparse matrices but works also with dense matrices. Changes the size of the matrix $m\cdot n\times m\cdot n$.

template<typename Matrix, typename PermVector, typename Vector>
Vector mtl::matrix::lu_adjoint_apply ( const Matrix &  LU,
const PermVector &  P,
const Vector &  b 
) [inline]

Apply the factorization L*U with permutation P on vector b to solve adjoint(A)x = b.

That is P^{-1}LU)^H x = b --> x= P^{-1}L^{-H} U^{-H} b where P^{-1}^{-1}^H = P^{-1}

template<typename MatrixA, typename MatrixB, typename MatrixC, typename Assign>
void mtl::matrix::mat_mat_mult ( const MatrixA &  a,
const MatrixB &  b,
MatrixC &  c,
Assign  ,
tag::sparse  ,
tag::dense  ,
tag::dense   
) [inline]

Product of sparse times dense matrix.

This function (specialization of mult) is intended to multiply sparse matrices with multiple matrices gathered into a dense matrix. Likewise, the resulting dense matrix corresponds to multiple vectors. The default functor for this operation is:

  1. Use tiled multiplication if available, otherwise
  2. Naive multiplication

template<typename MatrixA, typename MatrixB, typename MatrixC, typename Assign>
void mtl::matrix::mat_mat_mult ( const MatrixA &  a,
const MatrixB &  b,
MatrixC &  c,
Assign  ,
tag::dense  ,
tag::dense  ,
tag::dense   
) [inline]

Dense matrix multiplication.

The function for dense matrix multiplication defines a default multiplication functor. Alternatively the user can define his own functors for specific triplets of matrix types, see detail::dmat_dmat_mult_specialize. The default functor for dense matrix multiplication is:

  1. Use BLAS if available, otherwise
  2. Recursive multiplication with:
    1. Platform optimized mult on blocks if available, otherwise
    2. Tiled multiplication on blocks if available, otherwise
    3. Naive multiplication on blocks
  3. Naive multiplication on entire matrices if recursion is not available

Use user-defined functor if provided (assign mode can be arbitrary)

Finally substitute assign mode (consistently)

template<typename A, typename X, typename Y, typename Z>
void mtl::matrix::mult ( const A &  a,
const X &  x,
const Y &  y,
Z &  z 
) [inline]

Four term multiplication: mult(a, x, y, z) computes z= a * x + y;.

The 4 types must be compatible, i.e. a*x must be assignable to z and z must be incrementable by y. Right now, it is not more efficient than z= a * x; z+= y. For compatibility with MTL2.

template<typename A, typename B, typename C>
mtl::traits::enable_if_matrix<A>::type mtl::matrix::mult ( const A &  a,
const B &  b,
C &  c 
) [inline]

Multiplication: mult(a, b, c) computes c= a * b;.

The 3 types must be compatible, e.g. all three matrices or b and c are column vectors and a is a matrix. The dimensions are checked at compile time.

template<typename A, typename B, typename C>
mtl::traits::enable_if_matrix<A>::type mtl::matrix::mult_add ( const A &  a,
const B &  b,
C &  c 
) [inline]

Multiplication: mult_add(a, b, c) computes c+= a * b;.

The 3 types must be compatible, e.g. all three matrices or b and c are column vectors and a is a matrix. The dimensions are checked at compile time.

template<typename Matrix>
recursator<Matrix> mtl::matrix::north_east ( const recursator< Matrix > &  rec  )  [inline]

Compute the north-east quadrant of a recursator (i.e. its referred matrix). The result is itself a recursator.

See also:
recursion intro

template<typename Matrix>
recursator<Matrix> mtl::matrix::north_west ( const recursator< Matrix > &  rec  )  [inline]

Compute the north-west quadrant of a recursator (i.e. its referred matrix). The result is itself a recursator.

See also:
recursion intro

template<typename Matrix>
recursator<Matrix>::size_type mtl::matrix::num_cols ( const recursator< Matrix > &  rec  )  [inline]

The number of columns that a sub-matrix would have if it was constructed.

See also:
recursion intro

template<typename Matrix>
recursator<Matrix>::size_type mtl::matrix::num_rows ( const recursator< Matrix > &  rec  )  [inline]

The number of rows that a sub-matrix would have if it was constructed.

See also:
recursion intro

template<unsigned long Unroll, typename Matrix>
mtl::traits::enable_if_matrix< Matrix, typename RealMagnitude< typename Collection< Matrix >::value_type >::type >::type mtl::matrix::one_norm ( const Matrix &  matrix  )  [inline]

One-norm for matrices: one_norm(x) $\rightarrow |x|_1$.

Return values:
The magnitude type of the respective value type, see Magnitude.
The norms are defined as $|A|_1=\max_j\{\sum_i(|A_{ij}|)\}$. Matrix norms are not optimized by unrolling (yet).

template<typename Op1, typename Op2>
mtl::traits::mult_result<Op1, Op2>::type mtl::matrix::operator * ( const Op1 &  op1,
const Op2 &  op2 
) [inline]

Multiplication for all supported types of operations.

Enable-if-like technique make sure that only called when properly defined

template<typename Op1, typename Op2>
mtl::traits::div_result<Op1,Op2>::type mtl::matrix::operator/ ( const Op1 &  op1,
const Op2 &  op2 
) [inline]

Division of matrices and vectors by salars.

Enable-if-like technique make sure that only called when properly defined

template<typename Matrix, typename VectorX, typename VectorY>
void mtl::matrix::rank_one_update ( Matrix &  matrix,
const VectorX &  x,
const VectorY &  y 
) [inline]

Rank-one update: rank_one_update(A, x, y) computes A+= x * conj(y)^T.

The current implementation works for column and row vectors (although the notation above refers to column vectors).

template<typename Matrix, typename VectorX, typename VectorY>
void mtl::matrix::rank_two_update ( Matrix &  matrix,
const VectorX &  x,
const VectorY &  y 
) [inline]

Rank-two update: rank_two_update(A, x, y) computes A+= x * conj(y)^T + y * conj(x)^T.

The current implementation works for column and row vectors (although the notation above refers to column vectors).

template<typename Coll>
mtl::traits::enable_if_matrix< Coll >::type mtl::matrix::set_to_zero ( Coll &  collection  )  [inline]

Sets all values of a collection to 0 More spefically the defined multiplicative identity element

template<typename Matrix>
recursator<Matrix>::size_type mtl::matrix::size ( const recursator< Matrix > &  rec  )  [inline]

The number of elements (rows times columns) that a sub-matrix would have if it was constructed.

See also:
recursion intro

template<typename Matrix>
recursator<Matrix> mtl::matrix::south_east ( const recursator< Matrix > &  rec  )  [inline]

Compute the south-east quadrant of a recursator (i.e. its referred matrix). The result is itself a recursator.

See also:
recursion intro

template<typename Matrix>
recursator<Matrix> mtl::matrix::south_west ( const recursator< Matrix > &  rec  )  [inline]

Compute the south-west quadrant of a recursator (i.e. its referred matrix). The result is itself a recursator.

See also:
recursion intro

Variable Documentation

const std::size_t mtl::matrix::compressed_linear_search_limit = 10

Maximal number of entries that is searched linearly; above this std::lower_bound is used.

Can be reset with macro or corresponding compiler flag, e.g. {-D|/D}MTL_MATRIX_COMPRESSED_LINEAR_SEARCH_LIMIT=16

const std::size_t mtl::matrix::dense_non_recursive_product_limit = 10000

Maximal matrix size of dense matrices that is multiplied without recursion.

Can be reset with macro or corresponding compiler flag, e.g. {-D|/D}MTL_MATRIX_DENSE_NON_RECURSIVE_PRODUCT_LIMIT=4000

const std::size_t mtl::matrix::sorted_block_insertion_limit = 5

Maximal number of columns in block that is inserted separately; above this the block is presorted (only row-major sparse matrices).

Can be reset with macro or corresponding compiler flag, e.g. {-D|/D}MTL_SORTED_BLOCK_INSERTION_LIMIT=8 Default is 5.

mtl::matrix Namespace Reference -- MTL 4 -- Peter Gottschling and Andrew Lumsdaine -- Generated on 13 Nov 2009 by Doxygen 1.5.2 -- Copyright 2008-09 by TU Dresden and the Trustees of Indiana University.