mirror of
https://github.com/boostorg/ublas.git
synced 2026-02-22 15:52:18 +00:00
removed functions
This commit is contained in:
Michael Stevens
@@ -1,201 +0,0 @@
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
|
||||
<html xmlns="http://www.w3.org/1999/xhtml">
|
||||
<head>
|
||||
<meta name="generator" content=
|
||||
"HTML Tidy for Linux/x86 (vers 1st March 2004), see www.w3.org" />
|
||||
<meta name="GENERATOR" content="Quanta Plus" />
|
||||
<meta http-equiv="Content-Type" content=
|
||||
"text/html; charset=us-ascii" />
|
||||
<link href="ublas.css" type="text/css" />
|
||||
<title>uBLAS functions overview</title>
|
||||
</head>
|
||||
<body>
|
||||
<h1><img src="c++boost.gif" alt="c++boost.gif" align="middle" />
|
||||
Overview of Matrix and Vector Operations</h1>
|
||||
|
||||
<dl>
|
||||
<dt>Contents:</dt>
|
||||
<dd><a href="#blas">Basic Linear Algebra</a></dd>
|
||||
<dd><a href="#advanced">Advanced Functions</a></dd>
|
||||
<dd><a href="#sub">Submatrices, Subvectors</a></dd>
|
||||
<dd><a href="#speed">Speed Improvements</a></dd>
|
||||
</dl>
|
||||
|
||||
<h3>Definitions:</h3>
|
||||
|
||||
<table style="" summary="notation">
|
||||
<tr><td><code>A, B, C</code></td>
|
||||
<td> are matrices</td></tr>
|
||||
<tr><td><code>u, v, w</code></td>
|
||||
<td>are vectors</td></tr>
|
||||
<tr><td><code>i, j, k</code></td>
|
||||
<td>are integer values</td></tr>
|
||||
<tr><td><code>t, t1, t2</code></td>
|
||||
<td>are scalar values</td></tr>
|
||||
<tr><td><code>r, r1, r2</code></td>
|
||||
<td>are <a href="storage.htm#range">ranges</a>, e.g. <code>range(0, 3)</code></td></tr>
|
||||
<tr><td><code>s, s1, s2</code></td>
|
||||
<td>are <a href="storage.htm#slice">slices</a>, e.g. <code>slice(0, 1, 3)</code></td></tr>
|
||||
</table>
|
||||
|
||||
<h2><a name="blas">Basic Linear Algebra</a></h2>
|
||||
|
||||
<h3>standard operations: addition, subtraction, multiplication by a
|
||||
scalar</h3>
|
||||
|
||||
<pre><code>
|
||||
C = A + B; C = A - B; C = -A;
|
||||
w = u + v; w = u - v; w = -u;
|
||||
C = t * A; C = A * t; C = A / t;
|
||||
w = t * u; w = u * t; w = u / t;
|
||||
</code></pre>
|
||||
|
||||
<h3>computed assignements</h3>
|
||||
|
||||
<pre><code>
|
||||
C += A; C -= A;
|
||||
w += u; w -= u;
|
||||
C *= t; C /= t;
|
||||
w *= t; w /= t;
|
||||
</code></pre>
|
||||
|
||||
<h3>inner, outer and other products</h3>
|
||||
|
||||
<pre><code>
|
||||
t = inner_prod(u, v);
|
||||
C = outer_prod(u, v);
|
||||
w = prod(A, u); w = prod(u, A); w = prec_prod(A, u); w = prec_prod(u, A);
|
||||
C = prod(A, B); C = prec_prod(A, B);
|
||||
w = element_prod(u, v); w = element_div(u, v);
|
||||
C = element_prod(A, B); C = element_div(A, B);
|
||||
</code></pre>
|
||||
|
||||
<h3>transformations</h3>
|
||||
|
||||
<pre><code>
|
||||
w = conj(u); w = real(u); w = imag(u);
|
||||
C = trans(A); C = conj(A); C = herm(A); C = real(A); C = imag(A);
|
||||
</code></pre>
|
||||
|
||||
<h2><a name="advanced">Advanced functions</a></h2>
|
||||
|
||||
<h3>norms</h3>
|
||||
|
||||
<pre><code>
|
||||
t = norm_inf(v); i = index_norm_inf(v);
|
||||
t = norm_1(v); t = norm_2(v);
|
||||
t = norm_inf(A); i = index_norm_inf(A);
|
||||
t = norm_1(A); t = norm_frobenius(A);
|
||||
</code></pre>
|
||||
|
||||
<h3>products</h3>
|
||||
|
||||
<pre><code>
|
||||
axpy_prod(A, u, w, true); // w = A * u
|
||||
axpy_prod(A, u, w, false); // w += A * u
|
||||
axpy_prod(u, A, w, true); // w = trans(A) * u
|
||||
axpy_prod(u, A, w, false); // w += trans(A) * u
|
||||
axpy_prod(A, B, C, true); // C = A * B
|
||||
axpy_prod(A, B, C, false); // C += A * B
|
||||
</code></pre>
|
||||
<p><em>Note:</em> The last argument (<code>bool init</code>) of
|
||||
<code>axpy_prod</code> is optional. Currently it defaults to
|
||||
<code>true</code>, but this may change in the future. Set the
|
||||
<code>init</code> to <code>true</code> is equivalent to call
|
||||
<code>w.clear()</code> before <code>axpy_prod</code>. Up to now
|
||||
there are some specialisation for compressed matrices that give a
|
||||
large speed up compared to <code>prod</code>.</p>
|
||||
<pre><code>
|
||||
w = block_prod<matrix_type, 64> (A, u); // w = A * u
|
||||
w = block_prod<matrix_type, 64> (u, A); // w = trans(A) * u
|
||||
C = block_prod<matrix_type, 64> (A, B); // w = A * B
|
||||
</code></pre>
|
||||
<p><em>Note:</em> The blocksize can be any integer. However, the
|
||||
total speed depends very strong on the combination of blocksize,
|
||||
CPU and compiler. The function <code>block_prod</code> is designed
|
||||
for large dense matrices.</p>
|
||||
<h3>rank-k updates</h3>
|
||||
<pre><code>
|
||||
opb_prod(A, B, C, true); // C = A * B
|
||||
opb_prod(A, B, C, false); // C += A * B
|
||||
</code></pre>
|
||||
<p><em>Note:</em> The last argument (<code>bool init</code>) of
|
||||
<code>opb_prod</code> is optional. Currently it defaults to
|
||||
<code>true</code>, but this may change in the future. This function
|
||||
may give a speedup if <code>A</code> has less columns than rows,
|
||||
because the product is computed as a sum of outer products.</p>
|
||||
|
||||
<h2><a name="sub">Submatrices, Subvectors</a></h2>
|
||||
|
||||
<p><em>Note:</em> A range <code>r = range(start, stop)</code>
|
||||
contains all indices <code>i</code> with <code>start <= i <
|
||||
stop</code>. A slice is something more general. The slice
|
||||
<code>s = slice(start, stride, size)</code> contains the indices
|
||||
<code>start, start+stride, ..., start+(size-1)*stride</code>. The
|
||||
stride can be 0 or negative! If <code>start >= stop</code> for a range
|
||||
or <code>size == 0</code> for a slice then it contains no elements.</p>
|
||||
<pre><code>
|
||||
w = project(u, r); // a subvector of u specifed by the index range r
|
||||
w = project(u, s); // a subvector of u specifed by the index slice s
|
||||
C = project(A, r1, r2); // a submatrix of A specified by the two index ranges r1 and r2
|
||||
C = project(A, s1, s2); // a submatrix of A specified by the two index slices s1 and s2
|
||||
w = row(A, i); w = column(A, j); // a row or column of matrix as a vector
|
||||
</code></pre>
|
||||
<p>There are to more ways to access some matrix elements as a
|
||||
vector:</p>
|
||||
<pre><code>matrix_vector_range<matrix_type> (A, r1, r2);
|
||||
matrix_vector_slice<matrix_type> (A, s1, s2);
|
||||
</code></pre>
|
||||
<p><em>Note:</em> These matrix proxies take a sequence of elements
|
||||
of a matrix and allow you to access these as a vector. In
|
||||
particular <code>matrix_vector_slice</code> can do this in a very
|
||||
general way. <code>matrix_vector_range</code> is less useful as the
|
||||
elements must lie along a diagonal.</p>
|
||||
<p><em>Example:</em> To access the first two elements of a sub
|
||||
column of a matrix we access the row with a slice with stride 1 and
|
||||
the column with a slice with stride 0 thus:<br />
|
||||
<code>matrix_vector_slice<matrix_type> (A, slice(0,1,2),
|
||||
slice(0,0,2));
|
||||
</code></p>
|
||||
|
||||
<h2><a name="speed">Speed improvements</a></h2>
|
||||
<h3>Matrix / Vector assignment</h3>
|
||||
<p>If you know for sure that the left hand expression and the right
|
||||
hand expression have no common storage, then assignment has
|
||||
no <em>aliasing</em>. A more efficient assignment can be specified
|
||||
in this case:</p>
|
||||
<pre><code>noalias(C) = prod(A, B);
|
||||
</code></pre>
|
||||
<p>This avoids the creation of a temporary matrix that is required in a normal assignment.
|
||||
'noalias' assignment requires that the left and right hand side be size conformant.</p>
|
||||
|
||||
<h3>Sparse element access</h3>
|
||||
<p>The matrix element access function <code>A(i1,i2)</code> or the equivalent vector
|
||||
element access functions (<code>v(i) or v[i]</code>) usually create 'sparse element proxies'
|
||||
when applied to a sparse matrix or vector. These <em>proxies</em> allow access to elements
|
||||
without having to worry about nasty C++ issues where references are invalidated.</p>
|
||||
<p>These 'sparse element proxies' can be implemented more efficiently when applied to <code>const</code>
|
||||
objects.
|
||||
Sadly in C++ there is no way to distinguish between an element access on the left and right hand side of
|
||||
an assignment. Most often elements on the right hand side will not be changed and therefore it would
|
||||
be better to use the <code>const</code> proxies. We can do this by making the matrix or vector
|
||||
<code>const</code> before accessing it's elements. For example:</p>
|
||||
<pre><code>value = const_cast<const VEC&>(v)[i]; // VEC is the type of V
|
||||
</code></pre>
|
||||
<p>If more then one element needs to be accessed <code>const_iterator</code>'s should be used
|
||||
in preference to <code>iterator</code>'s for the same reason. For the more daring 'sparse element proxies'
|
||||
can be completely turned off in uBLAS by defining the configuration macro <code>BOOST_UBLAS_NO_ELEMENT_PROXIES</code>.
|
||||
</p>
|
||||
|
||||
<hr />
|
||||
<p>Copyright (©) 2000-2004 Joerg Walter, Mathias Koch, Gunter
|
||||
Winkler, Michael Stevens<br />
|
||||
Permission to copy, use, modify, sell and distribute this document
|
||||
is granted provided this copyright notice appears in all copies.
|
||||
This document is provided ``as is'' without express or implied
|
||||
warranty, and with no claim as to its suitability for any
|
||||
purpose.</p>
|
||||
<p>Last revised: 2004-08-09</p>
|
||||
</body>
|
||||
</html>
|
||||
@@ -1,17 +0,0 @@
|
||||
Welcome to the evaluation of our C++ matrix library.
|
||||
|
||||
Tests and benchmarks:
|
||||
Test1 contains a couple of basic tests for dense vectors and matrices.
|
||||
Test2 demonstrates how to emulate BLAS with this matrix library.
|
||||
Test3 contains a couple of basic tests for sparse vectors and matrices.
|
||||
Test4 contains a couple of basic tests for banded matrices.
|
||||
Test5 contains a couple of basic tests for triangular matrices.
|
||||
Test6 contains a couple of basic tests for symmetric matrices.
|
||||
Test7 contains a couple of basic tests for dense vectors and matrices of
|
||||
boost::numeric::interval(s).
|
||||
Bench1 measures the abstraction penalty using certain dense matrix and vector
|
||||
operations.
|
||||
Bench2 measures the performance of sparse matrix and vector operations.
|
||||
Bench3 measures the performance of vector and matrix proxy's operations.
|
||||
Bench4 measures the abstraction penalty using certain dense matrix and vector
|
||||
operations with boost::numeric::interval(s).
|
||||
571
doc/types.htm
571
doc/types.htm
@@ -1,571 +0,0 @@
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
|
||||
<html xmlns="http://www.w3.org/1999/xhtml">
|
||||
<head>
|
||||
<meta name="generator" content=
|
||||
"HTML Tidy for Linux/x86 (vers 1st March 2004), see www.w3.org" />
|
||||
<meta name="GENERATOR" content="Quanta Plus" />
|
||||
<link href="ublas.css" type="text/css" />
|
||||
<title>Types Overview</title>
|
||||
</head>
|
||||
<body>
|
||||
<h1><img src="c++boost.gif" alt="c++boost.gif" align="middle" />
|
||||
Overview of Matrix- and Vector-Types </h1>
|
||||
|
||||
<dl>
|
||||
<dt>Contents:</dt>
|
||||
<dd><a href="#vectors">Vectors</a></dd>
|
||||
<dd><a href="#vector_proxies">Vector Proxies</a></dd>
|
||||
<dd><a href="#matrices">Matrices</a></dd>
|
||||
<dd><a href="#matrix_proxies">Matrix Proxies</a></dd>
|
||||
<dd><a href="#storage_layout">Special Storage Layouts</a></dd>
|
||||
</dl>
|
||||
|
||||
|
||||
<h3>Notation:</h3>
|
||||
|
||||
<table style="border: none;" summary="notation">
|
||||
<tr><td><code>T</code></td>
|
||||
<td>is the data type. For general linear algebra operations this will be a real type e.g. <code>double</code>, ...</td></tr>
|
||||
<tr><td><code>F</code></td>
|
||||
<td>is the orientation type (functor), either
|
||||
<code>row_major</code> or <code>column_major</code></td></tr>
|
||||
<tr><td><code>A, IA, TA</code></td> <td>is an array storage type, e.g. <code>std::vector,
|
||||
bounded_array, unbounded_array, ...</code></td></tr>
|
||||
<tr><td><code>TRI</code></td>
|
||||
<td>is a triangular functor: <code>lower,
|
||||
unit_lower, strict_lower, upper, unit_upper,
|
||||
strict_upper</code></td></tr>
|
||||
<tr><td><code>M, N</code></td>
|
||||
<td>are unsigned integer sizes
|
||||
(<code>std::size_t</code>)</td></tr>
|
||||
<tr><td><code>IB</code></td>
|
||||
<td>is an index base
|
||||
(<code>std::size_t</code>)</td></tr>
|
||||
<tr><td><code>VEC</code></td>
|
||||
<td>is any vector type</td></tr>
|
||||
<tr><td><code>MAT</code> </td>
|
||||
<td>is any matrix type</td></tr>
|
||||
<tr><td><code>[...]</code></td>
|
||||
<td>denote optional arguments - for more details
|
||||
look at the section "storage layout".</td></tr>
|
||||
</table>
|
||||
|
||||
<h2><a name="vectors">Vectors</a></h2>
|
||||
<table border="1" summary="vector types">
|
||||
<thead>
|
||||
<tr>
|
||||
<th width="30%">Definition</th>
|
||||
<th>Description</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<tr>
|
||||
<td><code>vector<T [, A]><br /> v(size);</code></td>
|
||||
<td>a dense vector of values of type <code>T</code> of variable
|
||||
size. A storage type <code>A</code> can be specified
|
||||
which defaults to <code>unbounded_array</code>.
|
||||
Elements are zeroed by default.</td>
|
||||
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>bounded_vector<T, N><br /> v;</code></td>
|
||||
<td>a dense vector of values of type <code>T</code> of variable size but with maximum
|
||||
<code>N</code>. The default constructor creates <code>v</code>
|
||||
with size <code>N</code>.
|
||||
Elements are zeroed by default.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>c_vector<T, M><br /> v(size);</code></td>
|
||||
<td>a dense vector of values of type <code>T</code> with the given size.
|
||||
The data is stored as an ordinary C++ array <code>T
|
||||
data_[M]</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>zero_vector<T><br /> v(size);</code></td>
|
||||
<td>the zero vector of type <code>T</code> with the given
|
||||
size.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>unit_vector<T><br /> v(size, index);</code></td>
|
||||
<td>the unit vector of type <code>T</code> with the given size. The
|
||||
vector is zero other then a single specified element.
|
||||
<br/><code>index</code> should be less than <code>size</code>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>sparse_vector<T [, S]><br /> v(size);</code></td>
|
||||
<td>a sparse vector of values of type <code>T</code> of variable
|
||||
size. The sparse storage type <code>S</code> can be <code>std::map<size_t,
|
||||
T></code> or <code>map_array<size_t, T></code>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>compressed_vector<T [,IB, IA, TA]><br /> v(size);</code></td>
|
||||
<td>a sparse vector of values of type <code>T</code> 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
|
||||
the is at most one entry for each index.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>coordinate_vector<T [,IB, IA, TA]><br /> v(size);</code></td>
|
||||
<td>a sparse vector of values of type <code>T</code> 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.</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
<p><em>Note:</em> the default types are defined in
|
||||
<code>boost/numeric/ublas/fwd.hpp</code>.</p>
|
||||
|
||||
<h2><a name="vector_proxies">Vector Proxies</a></h2>
|
||||
|
||||
<table border="1" summary="vector proxies">
|
||||
<thead>
|
||||
<tr>
|
||||
<th width="30%">Definition</th>
|
||||
<th>Description</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<tr>
|
||||
<td><code>vector_range<VEC><br /> vr(v, range);</code></td>
|
||||
<td>a vector referencing a continuous subvector of elements of
|
||||
vector <code>v</code> containing all elements specified by
|
||||
<code>range</code>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>vector_slice<VEC><br /> vs(v, slice);</code></td>
|
||||
<td>a vector referencing a non continuous subvector of elements of
|
||||
vector <code>v</code> containing all elements specified by
|
||||
<code>slice</code>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>matrix_row<MAT><br /> vr(m, index);</code></td>
|
||||
<td>a vector referencing the <code>index</code>-th row of matrix
|
||||
<code>m</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>matrix_column<MAT><br /> vc(m, index);</code></td>
|
||||
<td>a vector referencing the <code>index</code>-th column of matrix
|
||||
<code>m</code></td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
|
||||
<h2><a name="matrices">Matrices</a></h2>
|
||||
|
||||
<table border="1" summary="matrix types">
|
||||
<thead>
|
||||
<tr>
|
||||
<th width="30%">Definition</th>
|
||||
<th>Description</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<tr>
|
||||
<td><code>matrix<T [, F, A]><br /> m(size1, size2);</code></td>
|
||||
<td>a dense matrix of values of type <code>T</code> of variable
|
||||
size. A storage type <code>A</code> can be specified
|
||||
which defaults to <code>unbounded_array</code>.
|
||||
The orientation functor <code>F</code> defaults to
|
||||
<code>row_major</code>.
|
||||
Elements are zeroed by default.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>bounded_matrix<T, M, N [, F]><br /> m;</code></td>
|
||||
<td>a dense matrix of type <code>T</code> with variable size with maximum <code>M</code>-by-<code>N</code>. The orientation functor <code>F</code>
|
||||
defaults to <code>row_major</code>. The default constructor creates
|
||||
<code>m</code> with size <code>M</code>-by-<code>N</code>.
|
||||
Elements are zeroed by default.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>c_matrix<T, M, N><br /> m(size1, size2);</code></td>
|
||||
<td>a dense matrix of values of type <code>T</code> with the given size.
|
||||
The data is stored as an ordinary C++ array <code>T
|
||||
data_[N][M]</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>vector_of_vector<T [, F, A]><br /> m(size1,
|
||||
size2);</code></td>
|
||||
<td>a dense matrix of values of type <code>T</code> with the given size.
|
||||
The data is stored as a vector of vectors. The orientation
|
||||
<code>F</code> defaults to <code>row_major</code>. The storage
|
||||
type <code>S</code> defaults to
|
||||
<code>unbounded_array<unbounded_array<T> ></code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>zero_matrix<T><br /> m(size1, size2);</code></td>
|
||||
<td>a zero matrix of type <code>T</code> with the given size.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>identity_matrix<T><br /> m(size1, size2);</code></td>
|
||||
<td>an identity matrix of type <code>T</code> with the given size.
|
||||
The values are <code>v(i,j) = (i==j)?T(1):T()</code>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>scalar_matrix<T><br /> m(size1, size2,
|
||||
value);</code></td>
|
||||
<td>a matrix of type <code>T</code> with the given size that has the
|
||||
value <code>value</code> everywhere.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>triangular_matrix<T [, TRI, F, A]><br />
|
||||
m(size);</code></td>
|
||||
<td>a triangular matrix of values of type <code>T</code> of
|
||||
variable size. Only the nonzero elements are stored in the given
|
||||
order <code>F</code>. ("triangular packed storage") The triangular
|
||||
type <code>F</code> defaults to <code>lower</code>, the orientation
|
||||
type <code>F</code> defaults to <code>row_major</code>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>banded_matrix<T [, F, A]><br /> m(size1, size2, n_lower,
|
||||
n_upper);</code></td>
|
||||
<td>a banded matrix of values of type <code>T</code> of variable
|
||||
size with <code>n_lower</code> sub diagonals and
|
||||
<code>n_upper</code> super diagonals. Only the nonzero elements are
|
||||
stored in the given order <code>F</code>. ("packed storage")</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>symmetric_matrix<T [, TRI, F, A]><br />
|
||||
m(size);</code></td>
|
||||
<td>a symmetric matrix of values of type <code>T</code> of
|
||||
variable size. Only the given triangular matrix is stored in the
|
||||
given order <code>F</code>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>hermitian_matrix<T [, TRI, F, A]><br />
|
||||
m(size);</code></td>
|
||||
<td>a hermitian matrix of values of type <code>T</code> of
|
||||
variable size. Only the given triangular matrix is stored using
|
||||
the order <code>F</code>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>sparse_matrix<T, [F, S]><br /> m(size1, size2 [,
|
||||
non_zeros]);</code></td>
|
||||
<td>a sparse matrix of values of type <code>T</code> of variable
|
||||
size. The sparse storage type <code>S</code> can be either <code>std::map<size_t,
|
||||
std::map<size_t, T> ></code> or
|
||||
<code>map_array<size_t, map_array<size_t,
|
||||
T> ></code>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>sparse_vector_of_sparse_vector<T, [F, C]><br /> m(size1,
|
||||
size2 [, non_zeros]);</code></td>
|
||||
<td>a sparse matrix of values of type <code>T</code> of variable
|
||||
size.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>compressed_matrix<T, [F, IB, IA, TA]><br /> m(size1,
|
||||
size2 [, non_zeros]);</code></td>
|
||||
<td>a sparse matrix of values of type <code>T</code> of variable
|
||||
size. The values are stored in compressed row/column storage.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>coordinate_matrix<T, [F, IB, IA, TA]><br /> m(size1,
|
||||
size2 [, non_zeros]);</code></td>
|
||||
<td>a sparse matrix of values of type <code>T</code> 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.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>generalized_vector_of_vector<T, F, A><br /> m(size1,
|
||||
size2 [, non_zeros]);</code></td>
|
||||
<td>a sparse matrix of values of type <code>T</code> of variable
|
||||
size. The values are stored as a vector of sparse vectors, e.g.
|
||||
<code>generalized_vector_of_vector<double, row_major,
|
||||
unbounded_array<coordinate_vector<double> > ></code></td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
<p><em>Note:</em> the default types are defined in
|
||||
<code>boost/numeric/ublas/fwd.hpp</code>.</p>
|
||||
|
||||
<h2><a name="matrix_proxies">Matrix Proxies</a></h2>
|
||||
|
||||
<table border="1" summary="matrix proxies">
|
||||
<thead>
|
||||
<tr>
|
||||
<th width="30%">Definition</th>
|
||||
<th>Description</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<tr>
|
||||
<td><code>triangular_adaptor<MAT, TRI><br /> ta(m);</code></td>
|
||||
<td>a triangular matrix referencing a selection of elements of the
|
||||
matrix <code>m</code>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>symmetric_adaptor<MAT, TRI><br /> sa(m);</code></td>
|
||||
<td>a symmetric matrix referencing a selection of elements of the
|
||||
matrix <code>m</code>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>hermitian_adaptor<MAT, TRI><br /> ha(m);</code></td>
|
||||
<td>a hermitian matrix referencing a selection of elements of the
|
||||
matrix <code>m</code>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>banded_adaptor<MAT><br /> ba(m, n_lower,
|
||||
n_upper);</code></td>
|
||||
<td>a banded matrix referencing a selection of elements of the
|
||||
matrix <code>m</code>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>matrix_range<MAT, TRI><br /> mr(m, range1,
|
||||
range2);</code></td>
|
||||
<td>a matrix referencing a submatrix of elements in the matrix
|
||||
<code>m</code>.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>matrix_slice<MAT, TRI><br /> ms(m, slice1,
|
||||
slice2);</code></td>
|
||||
<td>a matrix referencing a non continues submatrix of elements in
|
||||
the matrix <code>m</code>.</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
|
||||
|
||||
|
||||
<h2><a name="storage_layout">Special Storage Layouts</a></h2>
|
||||
|
||||
|
||||
<p>The library supports conventional dense, packed and basic sparse
|
||||
vector and matrix storage layouts. The description of the most
|
||||
common constructions of vectors and matrices comes next.</p>
|
||||
|
||||
<table border="1" summary="storage layouts">
|
||||
<tbody>
|
||||
<tr>
|
||||
<th width="30%">Construction</th>
|
||||
<th>Comment</th>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>vector<T,<br />
|
||||
std::vector<T> ><br />
|
||||
v (size)</code></td>
|
||||
<td>a dense vector, storage is provided by a standard
|
||||
vector.<br />
|
||||
The storage layout usually is BLAS compliant.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>vector<T,<br />
|
||||
unbounded_array<T> ><br />
|
||||
v (size)</code></td>
|
||||
<td>a dense vector, storage is provided by a heap-based
|
||||
array.<br />
|
||||
The storage layout usually is BLAS compliant.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>vector<T,<br />
|
||||
bounded_array<T, N> ><br />
|
||||
v (size)</code></td>
|
||||
<td>a dense vector, storage is provided by a stack-based
|
||||
array.<br />
|
||||
The storage layout usually is BLAS compliant.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>sparse_vector<T,<br />
|
||||
std::map<std::size_t, T> ><br />
|
||||
v (size, non_zeros)</code></td>
|
||||
<td>a sparse vector, storage is provided by a standard
|
||||
map.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>sparse_vector<T,<br />
|
||||
map_array<std::size_t, T> ><br />
|
||||
v (size, non_zeros)</code></td>
|
||||
<td>a sparse vector, storage is provided by a map
|
||||
array.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>matrix<T,<br />
|
||||
row_major,<br />
|
||||
std::vector<T> ><br />
|
||||
m (size1, size2)</code></td>
|
||||
<td>a dense matrix, orientation is row major, storage is
|
||||
provided by a standard vector.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>matrix<T,<br />
|
||||
column_major,<br />
|
||||
std::vector<T> ><br />
|
||||
m (size1, size2)</code></td>
|
||||
<td>a dense matrix, orientation is column major, storage
|
||||
is provided by a standard vector.<br />
|
||||
The storage layout usually is BLAS compliant.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>matrix<T,<br />
|
||||
row_major,<br />
|
||||
unbounded_array<T> ><br />
|
||||
m (size1, size2)</code></td>
|
||||
<td>a dense matrix, orientation is row major, storage is
|
||||
provided by a heap-based array.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>matrix<T,<br />
|
||||
column_major,<br />
|
||||
unbounded_array<T> ><br />
|
||||
m (size1, size2)</code></td>
|
||||
<td>a dense matrix, orientation is column major, storage
|
||||
is provided by a heap-based array.<br />
|
||||
The storage layout usually is BLAS compliant.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>matrix<T,<br />
|
||||
row_major,<br />
|
||||
bounded_array<T, N1 * N2> ><br />
|
||||
m (size1, size2)</code></td>
|
||||
<td>a dense matrix, orientation is row major, storage is
|
||||
provided by a stack-based array.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>matrix<T,<br />
|
||||
column_major,<br />
|
||||
bounded_array<T, N1 * N2> ><br />
|
||||
m (size1, size2)</code></td>
|
||||
<td>a dense matrix, orientation is column major, storage
|
||||
is provided by a stack-based array.<br />
|
||||
The storage layout usually is BLAS compliant.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>triangular_matrix<T,<br />
|
||||
row_major, F, A><br />
|
||||
m (size)</code></td>
|
||||
<td>a packed triangular matrix, orientation is row
|
||||
major.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>triangular_matrix<T,<br />
|
||||
column_major, F, A><br />
|
||||
m (size)</code></td>
|
||||
<td>a packed triangular matrix, orientation is column
|
||||
major.<br />
|
||||
The storage layout usually is BLAS compliant.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>banded_matrix<T,<br />
|
||||
row_major, A><br />
|
||||
m (size1, size2, lower, upper)</code></td>
|
||||
<td>a packed banded matrix, orientation is row
|
||||
major.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>banded_matrix<T,<br />
|
||||
column_major, A><br />
|
||||
m (size1, size2, lower, upper)</code></td>
|
||||
<td>a packed banded matrix, orientation is column
|
||||
major.<br />
|
||||
The storage layout usually is BLAS compliant.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>symmetric_matrix<T,<br />
|
||||
row_major, F, A><br />
|
||||
m (size)</code></td>
|
||||
<td>a packed symmetric matrix, orientation is row
|
||||
major.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>symmetric_matrix<T,<br />
|
||||
column_major, F, A><br />
|
||||
m (size)</code></td>
|
||||
<td>a packed symmetric matrix, orientation is column
|
||||
major.<br />
|
||||
The storage layout usually is BLAS compliant.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>hermitian_matrix<T,<br />
|
||||
row_major, F, A><br />
|
||||
m (size)</code></td>
|
||||
<td>a packed hermitian matrix, orientation is row
|
||||
major.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>hermitian_matrix<T,<br />
|
||||
column_major, F, A><br />
|
||||
m (size)</code></td>
|
||||
<td>a packed hermitian matrix, orientation is column
|
||||
major.<br />
|
||||
The storage layout usually is BLAS compliant.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>sparse_matrix<T,<br />
|
||||
row_major,<br />
|
||||
std::map<std::size_t, T> ><br />
|
||||
m (size1, size2, non_zeros)</code></td>
|
||||
<td>a sparse matrix, orientation is row major, storage
|
||||
is provided by a standard map.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>sparse_matrix<T,<br />
|
||||
column_major,<br />
|
||||
std::map<std::size_t, T> ><br />
|
||||
m (size1, size2, non_zeros)</code></td>
|
||||
<td>a sparse matrix, orientation is column major,
|
||||
storage is provided by a standard map.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>sparse_matrix<T,<br />
|
||||
row_major,<br />
|
||||
map_array<std::size_t, T> ><br />
|
||||
m (size1, size2, non_zeros)</code></td>
|
||||
<td>a sparse matrix, orientation is row major, storage
|
||||
is provided by a map array.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>sparse_matrix<T,<br />
|
||||
column_major,<br />
|
||||
map_array<std::size_t, T> ><br />
|
||||
m (size1, size2, non_zeros)</code></td>
|
||||
<td>a sparse matrix, orientation is column major,
|
||||
storage is provided by a map array.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>compressed_matrix<T,<br />
|
||||
row_major><br />
|
||||
m (size1, size2, non_zeros)</code></td>
|
||||
<td>a compressed matrix, orientation is row major.<br />
|
||||
The storage layout usually is BLAS compliant.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>compressed_matrix<T,<br />
|
||||
column_major><br />
|
||||
m (size1, size2, non_zeros)</code></td>
|
||||
<td>a compressed matrix, orientation is column
|
||||
major.<br />
|
||||
The storage layout usually is BLAS compliant.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>coordinate_matrix<T,<br />
|
||||
row_major><br />
|
||||
m (size1, size2, non_zeros)</code></td>
|
||||
<td>a coordinate matrix, orientation is row major.<br />
|
||||
The storage layout usually is BLAS compliant.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>coordinate_matrix<T,<br />
|
||||
column_major><br />
|
||||
m (size1, size2, non_zeros)</code></td>
|
||||
<td>a coordinate matrix, orientation is column
|
||||
major.<br />
|
||||
The storage layout usually is BLAS compliant.</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
|
||||
<hr />
|
||||
<p>Copyright (©) 2000-2004 Joerg Walter, Mathias Koch, Gunter
|
||||
Winkler, Michael Stevens<br />
|
||||
Permission to copy, use, modify, sell and distribute this document
|
||||
is granted provided this copyright notice appears in all copies.
|
||||
This document is provided ``as is'' without express or implied
|
||||
warranty, and with no claim as to its suitability for any
|
||||
purpose.</p>
|
||||
<p>Last revised: 2004-08-08</p>
|
||||
</body>
|
||||
</html>
|
||||
Reference in New Issue
Block a user