MTL Index [MTL Home]
Concept index

ColumnMatrix
A Column-Oriented MTL Matrix

DiagonalMatrix
A Diagonally-Oriented Matrix

IndexedIterator
IndexedIterator

Indexer
Maps from Matrix coordinates to TwoD coordinates

MTL_Object_Model
The MTL Object Memory Model

Matrix
The MTL Matrix Concept

Offset
Maps from TwoD coordinates to linear memory

OneDIndexer
OneDIndexer

RowMatrix
A Row-Oriented MTL Matrix

TwoDStorage
The MTL TwoD Storage Concept

Vector
The MTL Vector Concept
Class index

Dim

__bracket<Strided>

__mult__8<int M, int N>

__mult_fixn<int M>

_bogus

add<int N>
Add y <- x + y

add_op<int M, IterY>

array2D<OneD_>
Array 2-D Container

band_view<Matrix>
Band View Matrix Type Constructor

banded_indexer<size_type, Orien>

banded_offset<size_t, int MM, int NN>
Banded Offset Class

banded_view_offset<size_t, int MM, int NN>
Banded View Offset Class

blk<int BM, int BN>

block_view<Matrix, int BM = 0, int BN = 0>
Block View Matrix Type Constructor

choose<Cat>

column_matrix<TwoDGen, IndexerGen>
column matrix

column_matrix_traits<Matrix>
Column Matrix Traits

columns_type<Matrix>

compressed1D<T, SizeType = int, int IND_OFFSET = index_from_zero, Orien = no_orientation_tag>
Compressed Sparse Vector

compressed2D<T, SizeType, int IND_OFFSET>
Sparse matrix storage format with internal storage

compressed_iter<int isConst, Value, Index, int IND_OFFSET>
Compressed Storage Iterator

const_sparse_iterator<Iterator, T>

constant_stride_generator<RandomAccessIterator>

copy<int N>
Copy y <- x

copy__2<int M, int N>
Copy B <- A

dense_iterator<RandomAccessIterator, int IND_OFFSET=0, SizeType=int>
dense iterator

dense_iterator__2<T, int isConst, int IND_OFFSET=0, SizeType=int>

diagonal_matrix_old<TwoDGen, IndexerGen>
Diagonal Matrix

diagonal_matrix_traits<Matrix>
Diagonal Matrix Traits

dimension<sizet, int MM = DYNAMIC_SIZED, int NN = DYNAMIC_SIZED>
The Dimension Class

dims<int MM, int NN>
Row Orientation

dims__2<int MM, int NN>
Column Orientation

dot<int N>
Dot Product s <- x . y

elt_inserter

entry1<T>

expr_traits<TwoDGen, IndexerGen>

ext_comp2D<T, SizeType, int IND_OFFSET>
Sparse matrix storage format with external storage

external2D<T, OffsetGen, int MM = 0, int NN = 0>
External2D Storage Type

external_vec<T, int NN = 0, SizeType=unsigned int, Orien = column_tag>
External 1-D Container

gen_scaled1D<A, T>

general_stride_iterator<RandomAccessIterator, StrideGen>

generic_dense2D<RepType, RepPtr, OffsetGen, int MM, int NN>
Generic Dense 2-D Container

get_value_type<Dim, T>

get_value_type__2<T>

get_value_type__3<T>

givens_rotation<T>
Givens Plane Rotation

givens_rotation__2<T>
The specialization for complex numbers.

givens_rotation__3
The specialization for complex numbers.

givens_rotation__4
The specialization for complex numbers.

harwell_boeing_stream<T>
A Matrix File Input Stream for Harwell-Boeing Matrix Files

insert_iterator

lapack_matrix<T, int External=mtl::internal>
Lapack Matrix

linalg_category<T, SizeType, int IND_OFFSET, Orien>

linalg_category__2<TwoDGen, IndexerGen>

linalg_category__3<TwoDGen, IndexerGen>

linalg_traits<Linalg>
Linear Algebra Object (Matrix and Vector) Traits

make_dimsizes<Dim, T>

make_dimsizes__2<T>

make_dimsizes__3<T>

make_info<T>

matrix< T, Shape = rectangle<>, Storage = dense<>, Orientation = row_major >
Matrix type generators class.

matrix_implementation<TwoDGen, IndexerGen>
The main MTL matrix implementation type.

matrix_market_stream<T>
A Matrix File Input Stream for Matrix Market Files

matrix_traits<Matrix>
The "traits" class for MTL matrices.

modified_givens<T>
Modified Givens Transformation

mtl_multiplies<S, T, R>

mult<int M, int N>
Multiplication y <- A x + y

mult__2<int M, int N, int K>
Multiplication C <- A * B

mult_fixn<int M>

not_strideable
Identifies matrices that can not be used with the rows and columns functions

not_strided_tag

number_traits<number_type>

packed_offset<size_t, int MM, int NN>
Packed Offset Class

packed_strider

partitioned<SubMatrix>
Dense2D Storage Type

rank_one<int M, int N>
Rank One Update A <- A + x * y^T

rect_offset<size_t, int MM, int NN>
Rectangular Offset Class

row_matrix<TwoDGen, IndexerGen>
row matrix

row_matrix_traits<Matrix>
Row Matrix Traits

rows_type<Matrix>

scale_iterator<RandomAccessIterator, T>
scale iterator

scale_iterator__2<Iterator, T>

scaled1D<RandomAccessContainerRef>
Scaled Container

scaled2D<TwoD, T>
Scaled 2D container adaptor

set<int N>
Set elements of vector x to alpha

set__2<int M, int N>
Set matrix A to alpha

sparse1D<RepType, Orien = column_tag>
Sparse 1-D Container Adaptor

sparse_iterator<Iterator, T>
Sparse Vector Iterator

stride_iterator<RandomAccessIterator>

strideable
Identifies matrices that can be used with the rows and columns functions

strided1D<RandomAccessContainerRef>
Strided Vector Adaptor

strided_band_view_offset<size_t, int MM, int NN>
Strided Band View Offset Class

strided_banded_offset<size_t, int MM, int NN>
Strided Banded Offset

strided_iterator<RandomAccessIterator, int isConst>
strided iterator

strided_offset<size_t, int MM, int NN>
Strided Rectangular Offset Class

strided_packed_offset<size_t, int MM, int NN>
Strided Packed Offset Class

strided_tag

symmetric_matrix_old<Base_, Uplo, bool IsHerm >
symmetric and hermitian

symmetric_view<Matrix, uplo_e Uplo>
Symmetric View Matrix Type Constructor

transform_iterator<Iterator, AdaptableUnaryFunction>
Tranforming Iterator

transform_iterator__2<RandomAccessIterator, AdaptableUnaryFunction>

tri_view<uplo_e Uplo>
Triangle View Creation Helper Fuctor

triangle_matrix_old<Base_, Uplo>
triangle

triangle_view<Matrix, uplo_e Uplo>
Triangle View Matrix Type Constructor
Function index

scaled
Shortcut for Creating a Scaled Argument

strided
Shortcut for Creating a Strided Argument

blocked
Blocked Matrix Generator

blocked
Blocked Matrix Generator

rows
Access the row-wise view of the matrix

columns
Access the column-wise view of the matrix

trans
Swap the orientation of a matrix.

sum
Sum: s <- sum_i(x(i))

scale
Scale: A <- alpha*A or x <- alpha x

set_diagonal
Set Diagonal: A(i,i) <- alpha

two_norm
Two Norm: s <- sqrt(sum_i(|x(i)^2|))

sum_squares
Sum of the Squares

one_norm
One Norm: s <- sum(|x_i|) or s <- max_j(sum_i(|A(i,j)|))

infinity_norm
Infinity Norm: s <- max_i(sum_j(|A(i,j)|)) or s <- max_i(|x(i)|)

max_index
Max Index: i <- index of max(|x(i)|)

max_abs_index
Maximum Absolute Index: i <- index of max(|x(i)|)

min_index
Minimum Index: i <- index of min(x(i))

min_abs_index
Minimum Absolute Index: i <- index of min(|x(i)|)

max
Max Value: s <- max(x(i))

min
Min Value: s <- min(x_i)

transpose
Transpose in Place: A <- A^T

conj_transpose
Transpose in Place: A <- A^T

transpose
Transpose: B <- A^T

mult
Multiplication: z <- A x + y

_mult
Matrix Vector Multiplication: y <- A x

tri_solve
Triangular Solve: x <- T^{-1} * x

tri_solve
Triangular Solve: B <- A^{-1} * B or B <- B * A^{-1}

rank_one_update
Rank One Update: A <- A + x * y^T

rank_one_conj
Rank One Update with conj(): A <- A + x * conj(y^T)

rank_two_update
Rank Two Update: A <- A + x * y^T + y * x^T

rank_two_conj
Rank Two Update with conj(): A <- A + x * conj(y^T) + y * conj(x^T)

scatter
Scatter y <- x

gather
Gather y <- x

copy
Copy: B <- A or y <- x

__add
Add: z <- x + y

add
Add: w <- x + y + z

add
Add: B <- A + B or y <- x + y

ele_mult
Element-wise Multiplication: z <- x O* y

ele_mult
Element-wise Multiply: B <- A O* B

ele_div
Element-wise Division: z <- x O/ y

swap
Swap: B <-> A or y <-> x

dot
Dot Product: s <- x . y + s

dot
Dot Product: s <- x . y

dot
Dot Product (extended precision): s <- x . y + s

dot_conj
Dot Conjugate: s <- x . conj(y) + s

dot_conj
Dot Conjugate: s <- x . conj(y)

copy
Copy

transform
Transform (one input iterator)

transform
Transform (two input iterators)

fill
Fill

swap_ranges
Swap Ranges

accumulate
Accumulate (with default operation)

accumulate
Accumulate (with user-supplied operation)

inner_product
Inner Product (user supplied operators)

inner_product
Inner Product (with default operators)

lu_factor
LU Factorization of a general (dense) matrix

lu_solve
LU Solve

lu_inverse
LU Inverse

trans_iter
Helper function for creating a transforming iterator

read_dense_matlab
Read a Dense Real Matrix from a Matlab file (.mat)

write_dense_matlab
Write a Dense Real Matrix to a Matlab file (.mat)

read_sparse_matlab
Read a Sparse Real Matrix from a Matlab file (.mat)

write_sparse_matlab
Write a Sparse Real Matrix to a Matlab file (.mat)

gecon
Estimate the reciprocal of the condition number of a general matrix.

geev
Compute the eigenvalues.

geqpf
QR Factorization with Column Pivoting.

geqrf
QR Factorization of a General Matrix

gesv
Solution to a linear system in a general matrix.

getrf
LU factorization of a general matrix A.

getrs
Solution to a system using LU factorization

geequ
Equilibrate and reduce condition number.

gelqf
Compute an LQ factorization.

orglq
Generate a matrix Q with orthonormal rows.

orgqr
Generate a matrix Q with orthonormal columns.

[MTL Home] Copyright © 1998,1999 University of Notre Dame. All Rights Reserved.