a dense vector of values of type T of variable
size. A storage type A can be specified
which defaults to unbounded_array.
Elements are constructed by A, which need not initialise their value.

bounded_vector<T, N> v;

a dense vector of values of type T of variable size but with maximum
N. The default constructor creates v
with size N.
Elements are constructed by the storage type bounded_array, which need not initialise their value.

c_vector<T, M> v(size);

a dense vector of values of type T with the given size.
The data is stored as an ordinary C++ array T
data_[M]

zero_vector<T> v(size);

the zero vector of type T with the given
size.

unit_vector<T> v(size, index);

the unit vector of type T with the given size. The
vector is zero other then a single specified element.
index should be less than size.

mapped_vector<T [, S]> v(size);

a sparse vector of values of type T of variable
size. The sparse storage type S can be std::map<size_t,
T> or map_array<size_t, T>.

compressed_vector<T [,IB, IA, TA]> v(size);

a sparse vector of values of type T of variable
size. The non zero values are stored as two seperate arrays - an
index array and a value array. The index array is always sorted and
there is at most one entry for each index.

coordinate_vector<T [,IB, IA, TA]> v(size);

a sparse vector of values of type T of variable
size. The non zero values are stored as two seperate arrays - an
index array and a value array. The arrays may be out of order with
multiple entries for each vector element. If there are multiple
values for the same index the sum of these values is the real
value.

a dense matrix of values of type T of variable
size. A storage type A can be specified
which defaults to unbounded_array.
The orientation functor F defaults to
row_major.
Elements are constructed by A, which need not initialise their value.

bounded_matrix<T, M, N [, F]> m;

a dense matrix of type T with variable size with maximum M-by-N. The orientation functor F
defaults to row_major. The default constructor creates
m with size M-by-N.
Elements are constructed by the storage type bounded_array, which need not initialise their value.

c_matrix<T, M, N> m(size1, size2);

a dense matrix of values of type T with the given size.
The data is stored as an ordinary C++ array T
data_[N][M]

vector_of_vector<T [, F, A]> m(size1,
size2);

a dense matrix of values of type T with the given size.
The data is stored as a vector of vectors. The orientation
F defaults to row_major. The storage
type S defaults to
unbounded_array<unbounded_array<T> >

zero_matrix<T> m(size1, size2);

a zero matrix of type T with the given size.

identity_matrix<T> m(size1, size2);

an identity matrix of type T with the given size.
The values are v(i,j) = (i==j)?T(1):T().

scalar_matrix<T> m(size1, size2,
value);

a matrix of type T with the given size that has the
value value everywhere.

triangular_matrix<T [, TRI, F, A]>
m(size);

a triangular matrix of values of type T of
variable size. Only the nonzero elements are stored in the given
order F. ("triangular packed storage") The triangular
type F defaults to lower, the orientation
type F defaults to row_major.

banded_matrix<T [, F, A]> m(size1, size2, n_lower,
n_upper);

a banded matrix of values of type T of variable
size with n_lower sub diagonals and
n_upper super diagonals. Only the nonzero elements are
stored in the given order F. ("packed storage")

symmetric_matrix<T [, TRI, F, A]>
m(size);

a symmetric matrix of values of type T of
variable size. Only the given triangular matrix is stored in the
given order F.

hermitian_matrix<T [, TRI, F, A]>
m(size);

a hermitian matrix of values of type T of
variable size. Only the given triangular matrix is stored using
the order F.

mapped_matrix<T, [F, S]> m(size1, size2 [,
non_zeros]);

a sparse matrix of values of type T of variable
size. The sparse storage type S can be either std::map<size_t,
std::map<size_t, T> > or
map_array<size_t, map_array<size_t,
T> >.

a sparse matrix of values of type T of variable
size. The values are stored in compressed row/column storage.

coordinate_matrix<T, [F, IB, IA, TA]> m(size1,
size2 [, non_zeros]);

a sparse matrix of values of type T of variable
size. The values are stored in 3 parallel array as triples (i, j,
value). More than one value for each pair of indices is possible,
the real value is the sum of all.

generalized_vector_of_vector<T, F, A> m(size1,
size2 [, non_zeros]);

a sparse matrix of values of type T of variable
size. The values are stored as a vector of sparse vectors, e.g.
generalized_vector_of_vector<double, row_major,
unbounded_array<coordinate_vector<double> > >