merged important changes from Toon's dense_vector_concept

dense_vector/matrix_concept did not yet have any difference from the container concepts and could be removed
The differences between dense and sparse can be added again later

svn path=/trunk/boost/libs/numeric/ublas/; revision=29565
This commit is contained in:
Michael Stevens 2005-06-14 17:05:03 +00:00
parent b2eaa3f450
commit b86ec57071
3 changed files with 51 additions and 658 deletions

View File

@ -12,22 +12,21 @@
<body>
<h1><img src="../../../../boost.png" align="middle" />
Container Concepts</h1>
<h2><a name="vector" id="vector"></a> Vector</h2>
<h2><a name="vector" id="vector"></a>Vector</h2>
<h4>Description</h4>
<p>A Vector describes common aspects of dense, packed and sparse
vectors.</p>
<h4>Refinement of</h4>
<p><a href="expression_concept.htm#vector_expression">Vector Expression</a>
.</p>
<p><a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a>,
<a href="http://www.sgi.com/tech/stl/RandomAccessContainer.html">RandomAccessContainer</a> and
<a href="expression_concept.htm#vector_expression">Vector Expression</a>
<a href="#vector_expression_note">[1]</a>.</p>
<h4>Associated types</h4>
<p>
In addition to the types defined int
<a href="expression_concept.htm#vector_expression">Vector Expression</a>
</p>
<table border="0" summary="types">
<p>In addition to the types defined by <a href="http://www.sgi.com/tech/stl/RandomAccessContainer.html">RandomAccessContainer</a> and <a href="expression_concept.htm#vector_expression">Vector Expression</a></p>
<table border="1" summary="types">
<tbody>
<tr>
<td>Storage</td>
<td>StorageArray</td>
<td>array_type</td>
<td>The type of underlying storage used to store the elements</td>
</tr>
@ -60,9 +59,9 @@ In addition to the types defined int
</table>
<h4>Definitions</h4>
<h4>Valid expressions</h4>
<p>In addition to the expressions defined in <a href=
"expression_concept.htm#vector_expression">Vector Expression</a> the
following expressions must be valid.</p>
<p>In addition to the expressions defined in <a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a>,
<a href="http://www.sgi.com/tech/stl/RandomAccessContainer.html">RandomAccessContainer</a> and
<a href="expression_concept.htm#vector_expression">Vector Expression</a> the following expressions must be valid.</p>
<table border="1" summary="expressions">
<tbody>
<tr>
@ -78,11 +77,6 @@ following expressions must be valid.</p>
<td><code>V</code></td>
</tr>
<tr>
<td>Element access <a href="#element_access_note">[1]</a></td>
<td><code>v[n]</code></td>
<td><code>n</code> is convertible to <code>size_type</code></td>
<td><code>reference</code> if v is mutable, <code>const_reference</code> otherwise</td>
</tr>
<tr>
<td>Insert</td>
<td><code>v.insert_element (i, t)</code></td>
@ -110,15 +104,9 @@ following expressions must be valid.</p>
</tr>
<tr>
<td>Storage</td>
<td><code>data() const</code></td>
<td></td>
<td><code>const array_type&amp;</code></td>
</tr>
<tr>
<td>Storage</td>
<td><code>data()</code></td>
<td><code>v</code> is mutable</td>
<td><code>array_type&amp;</code></td>
<td>&nbsp;</td>
<td><code>array_type&amp;</code> if a is mutable, <code>const array_type&amp;</code> otherwise</td>
</tr>
</tbody>
</table>
@ -142,11 +130,11 @@ from, or is not defined in <a href=
<td><code>v.size () == n</code>.</td>
</tr>
<tr>
<td>Element access <a href="#element_access_note">[1]</a></td>
<td>Element access <a href="#element_access_note">[2]</a></td>
<td><code>v[n]</code></td>
<td><code>0&lt;n&gt;v.size()</code></td>
<td>returns the n-th element in v</td>
<td></td>
<td>&nbsp;</td>
</tr>
<tr>
<td>Insert</td>
@ -189,16 +177,9 @@ When <code>p == false</code> then existing elements are not preserved and elemen
<tr>
<td>Storage</td>
<td><code>v.data()</code></td>
<td><code>v</code> is const</td>
<td><code>v</code></td>
<td>Returns a reference to the underlying storage</td>
<td></td>
</tr>
<tr>
<td>Storage</td>
<td><code>v.data()</code></td>
<td><code>v</code> is mutable</td>
<td>Returns a reference to the underlying storage</td>
<td></td>
<td>&nbsp;</td>
</tr>
</table>
<h4>Complexity guarantees</h4>
@ -216,21 +197,33 @@ size.</p>
<li><code>mapped_vector&lt;T&gt;</code> , <code>compressed_vector</code> , <code>coordinate_vector</code></li>
</ul>
<h4>Notes</h4>
<a name="element_access_note">[1]</a>The <code>operator[]</code> is added purely for convenience
<p><a name="vector_expression note">[1]</a>
As a user you need not care about <tt>Vector</tt> being a refinement of the VectorExpression. Being a refinement of the VectorExpression is only important for the template-expression engine but not the user.</p>
<p><a name="element_access_note">[2]</a>
The <code>operator[]</code> is added purely for convenience
and compatibility with the <code>std::vector</code>. In uBLAS however,
generally <code>operator()</code> is used for indexing because this can be
used for both vectors and matrices.
<h2><a name="matrix" id="matrix"></a> Matrix</h2>
used for both vectors and matrices.</p>
<h2><a name="matrix" id="matrix"></a>Matrix</h2>
<h4>Description</h4>
<p>A Matrix describes common aspects of dense, packed and sparse
matrices.</p>
<h4>Refinement of</h4>
<p><a href="expression_concept.htm#matrix_expression">Matrix Expression</a>
<p><a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a>,
<a href="expression_concept.htm#matrix_expression">Matrix Expression</a>
<a href="#matrix_expression_note">[1]</a>
.</p>
<h4>Associated types</h4>
<p>
See <a href="expression_concept.htm#matrix_expression">Matrix Expression</a>
</p>
<p>In addition to the types defined by <a href="http://www.sgi.com/tech/stl/RandomAccessContainer.html">RandomAccessContainer</a> and <a href="expression_concept.htm#matrix_expression">Matrix Expression</a></p>
<table border="1" summary="types">
<tbody>
<tr>
<td>StorageArray</td>
<td>array_type</td>
<td>The type of underlying storage used to store the elements</td>
</tr>
</tbody>
</table>
<h4>Notation</h4>
<table border="0" summary="notation">
<tbody>
@ -300,6 +293,12 @@ following expressions must be valid.</p>
<td><code>m</code> is mutable.</td>
<td><code>void</code></td>
</tr>
<tr>
<td>Storage</td>
<td><code>data()</code></td>
<td>&nbsp;</td>
<td><code>array_type&amp;</code> if a is mutable, <code>const array_type&amp;</code> otherwise</td>
</tr>
</tbody>
</table>
<h4>Expression semantics</h4>
@ -368,6 +367,12 @@ copies.<br />
When <code>p == false</code> then existing elements are not preserved and elements will not appended as normal. Instead the matrix is in the same state as that after an equivalent sizing constructor.</td>
<td><code>m.size1 () == n1</code> and <code>m.size2 () == n2</code>.</td>
</tr>
<tr>
<td>Storage</td>
<td><code>v.data()</code></td>
<td><code>v</code></td>
<td>Returns a reference to the underlying storage</td>
<td>&nbsp;</td>
</tbody>
</table>
<h4>Complexity guarantees</h4>
@ -385,6 +390,9 @@ size.</p>
<li><code>triangular_matrix&lt;T&gt;</code> , <code>symmetric_matrix&lt;T&gt;</code> , <code>banded_matrix&lt;T&gt;</code></li>
<li><code>mapped_matrix&lt;T&gt;</code> , <code>compressed_matrix</code> , <code>coordinate_matrix</code></li>
</ul>
<h4>Notes</h4>
<p><a name="matrix_expression note">[1]</a>
As a user you need not care about <tt>Matrix</tt> being a refinement of the MatrixExpression. Being a refinement of the MatrixExpression is only important for the template-expression engine but not the user.</p>
<hr />
<p>Copyright (&copy;) 2000-2002 Joerg Walter, Mathias Koch<br />
Permission to copy, use, modify, sell and distribute this document

View File

@ -1,397 +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 http-equiv="Content-Type" content=
"text/html; charset=us-ascii" />
<link href="ublas.css" type="text/css" />
<title>Container Concepts</title>
</head>
<body>
<h1><img src="../../../../boost.png" align="middle" />
Container Concepts</h1>
<h2><a name="vector" id="vector"></a> Vector</h2>
<h4>Description</h4>
<p>A Vector describes common aspects of dense, packed and sparse
vectors.</p>
<h4>Refinement of</h4>
<p><a href="expression_concept.htm#vector_expression">Vector Expression</a>
.</p>
<h4>Associated types</h4>
<p>
In addition to the types defined int
<a href="expression_concept.htm#vector_expression">Vector Expression</a>
</p>
<table border="0" summary="types">
<tbody>
<tr>
<td>Storage</td>
<td>array_type</td>
<td>The type of underlying storage used to store the elements</td>
</tr>
</tbody>
</table>
<h4>Notation</h4>
<table border="0" summary="notation">
<tbody>
<tr>
<td><code>V</code></td>
<td>A type that is a model of Vector</td>
</tr>
<tr>
<td><code>v</code></td>
<td>Objects of type <code>V</code></td>
</tr>
<tr>
<td><code>n, i</code></td>
<td>Objects of a type convertible to <code>size_type</code></td>
</tr>
<tr>
<td><code>t</code></td>
<td>Object of a type convertible to <code>value_type</code></td>
</tr>
<tr>
<td><code>p</code></td>
<td>Object of a type convertible to <code>bool</code></td>
</tr>
</tbody>
</table>
<h4>Definitions</h4>
<h4>Valid expressions</h4>
<p>In addition to the expressions defined in <a href=
"expression_concept.htm#vector_expression">Vector Expression</a> the
following expressions must be valid.</p>
<table border="1" summary="expressions">
<tbody>
<tr>
<th>Name</th>
<th>Expression</th>
<th>Type requirements</th>
<th>Return type</th>
</tr>
<tr>
<td>Sizing constructor</td>
<td><code>V v (n)</code></td>
<td>&nbsp;</td>
<td><code>V</code></td>
</tr>
<tr>
<td>Element access <a href="#element_access_note">[1]</a></td>
<td><code>v[n]</code></td>
<td><code>n</code> is convertible to <code>size_type</code></td>
<td><code>reference</code> if v is mutable, <code>const_reference</code> otherwise</td>
</tr>
<tr>
<td>Insert</td>
<td><code>v.insert_element (i, t)</code></td>
<td><code>v</code> is mutable.</td>
<td><code>void</code></td>
</tr>
<tr>
<td>Erase</td>
<td><code>v.erase_element (i)</code></td>
<td><code>v</code> is mutable.</td>
<td><code>void</code></td>
</tr>
<tr>
<td>Clear</td>
<td><code>v.clear ()</code></td>
<td><code>v</code> is mutable.</td>
<td><code>void</code></td>
</tr>
<tr>
<td>Resize</td>
<td><code>v.resize (n)</code><br />
<code>v.resize (n, p)</code></td>
<td><code>v</code> is mutable.</td>
<td><code>void</code></td>
</tr>
<tr>
<td>Storage</td>
<td><code>data() const</code></td>
<td></td>
<td><code>const array_type&amp;</code></td>
</tr>
<tr>
<td>Storage</td>
<td><code>data()</code></td>
<td><code>v</code> is mutable</td>
<td><code>array_type&amp;</code></td>
</tr>
</tbody>
</table>
<h4>Expression semantics</h4>
<p>Semantics of an expression is defined only where it differs
from, or is not defined in <a href=
"expression_concept.htm#vector_expression">Vector Expression</a> .</p>
<table border="1" summary="semantics">
<tr>
<th>Name</th>
<th>Expression</th>
<th>Precondition</th>
<th>Semantics</th>
<th>Postcondition</th>
</tr>
<tr>
<td>Sizing constructor</td>
<td><code>V v (n)</code></td>
<td><code>n &gt;= 0</code></td>
<td>Allocates a vector of<code>n</code> elements.</td>
<td><code>v.size () == n</code>.</td>
</tr>
<tr>
<td>Element access <a href="#element_access_note">[1]</a></td>
<td><code>v[n]</code></td>
<td><code>0&lt;n&gt;v.size()</code></td>
<td>returns the n-th element in v</td>
<td></td>
</tr>
<tr>
<td>Insert</td>
<td><code>v.insert_element (i, t)</code></td>
<td><code>0 &lt;= i &lt; v.size ()</code> and<br />
<code>v (i)</code> is equal to <code>value_type (0)</code>.</td>
<td>A copy of <code>t</code> is inserted in <code>v</code>.</td>
<td><code>v (i)</code> is a copy of <code>t</code>.</td>
</tr>
<tr>
<td>Erase</td>
<td><code>v.erase_element (i)</code></td>
<td><code>0 &lt;= i &lt; v.size ()</code></td>
<td>Destroys the element <code>v (i)</code> and replaces it with
<code>value_type ()</code>.</td>
<td><code>v (i)</code> is a copy of <code>value_type
()</code>.</td>
</tr>
<tr>
<td>Clear</td>
<td><code>v.clear ()</code></td>
<td>&nbsp;</td>
<td>Equivalent to<br />
<code>for (i = 0; i &lt; v.size (); ++ i)</code><br />
&nbsp; <code>v.erase (i);</code></td>
<td>&nbsp;</td>
</tr>
<tr>
<td>Resize</td>
<td><code>v.resize (n)
<br />v.resize (n, p)</code></td>
<td>&nbsp;</td>
<td>Reallocates the vector so that it can hold <code>n</code>
elements.<br />
Erases or appends elements in order to bring the vector to the prescribed size. Appended elements copies of <code>value_type()</code>.
<br />
When <code>p == false</code> then existing elements are not preserved and elements will not appended as normal. Instead the vector is in the same state as that after an equivalent sizing constructor.</td>
<td><code>v.size () == n</code>.</td>
</tr>
<tr>
<td>Storage</td>
<td><code>v.data()</code></td>
<td><code>v</code> is const</td>
<td>Returns a reference to the underlying storage</td>
<td></td>
</tr>
<tr>
<td>Storage</td>
<td><code>v.data()</code></td>
<td><code>v</code> is mutable</td>
<td>Returns a reference to the underlying storage</td>
<td></td>
</tr>
</table>
<h4>Complexity guarantees</h4>
<p>The run-time complexity of the sizing constructor is linear in
the vector's size.</p>
<p>The run-time complexity of insert_element and erase_element is specific for the
vector.</p>
<p>The run-time complexity of resize is linear in the vector's
size.</p>
<h4>Invariants</h4>
<h4>Models</h4>
<ul>
<li><code>vector&lt;T&gt;</code> , <code>bounded_vector&lt;T, N&gt;</code></li>
<li><code>unit_vector&lt;T&gt;</code> , <code>zero_vector&lt;T&gt;</code> , <code>scalar_vector&lt;T&gt;</code></li>
<li><code>mapped_vector&lt;T&gt;</code> , <code>compressed_vector</code> , <code>coordinate_vector</code></li>
</ul>
<h4>Notes</h4>
<a name="element_access_note">[1]</a>The <code>operator[]</code> is added purely for convenience
and compatibility with the <code>std::vector</code>. In uBLAS however,
generally <code>operator()</code> is used for indexing because this can be
used for both vectors and matrices.
<h2><a name="matrix" id="matrix"></a> Matrix</h2>
<h4>Description</h4>
<p>A Matrix describes common aspects of dense, packed and sparse
matrices.</p>
<h4>Refinement of</h4>
<p><a href="expression_concept.htm#matrix_expression">Matrix Expression</a>
.</p>
<h4>Associated types</h4>
<p>
See <a href="expression_concept.htm#matrix_expression">Matrix Expression</a>
</p>
<h4>Notation</h4>
<table border="0" summary="notation">
<tbody>
<tr>
<td><code>M</code></td>
<td>A type that is a model of Matrix</td>
</tr>
<tr>
<td><code>m</code></td>
<td>Objects of type <code>M</code></td>
</tr>
<tr>
<td><code>n1, n2, i, j</code></td>
<td>Objects of a type convertible to <code>size_type</code></td>
</tr>
<tr>
<td><code>t</code></td>
<td>Object of a type convertible to <code>value_type</code></td>
</tr>
<tr>
<td><code>p</code></td>
<td>Object of a type convertible to <code>bool</code></td>
</tr>
</tbody>
</table>
<h4>Definitions</h4>
<h4>Valid expressions</h4>
<p>In addition to the expressions defined in <a href=
"expression_concept.htm#matrix_expression">Matrix Expression</a> the
following expressions must be valid.</p>
<table border="1" summary="expressions">
<tbody>
<tr>
<th>Name</th>
<th>Expression</th>
<th>Type requirements</th>
<th>Return type</th>
</tr>
<tr>
<td>Sizing constructor</td>
<td><code>M m (n1, n2)</code></td>
<td>&nbsp;</td>
<td><code>M</code></td>
</tr>
<tr>
<td>Insert</td>
<td><code>m.insert_element (i, j, t)</code></td>
<td><code>m</code> is mutable.</td>
<td><code>void</code></td>
</tr>
<tr>
<td>Erase</td>
<td><code>m.erase_element (i, j)</code></td>
<td><code>m</code> is mutable.</td>
<td><code>void</code></td>
</tr>
<tr>
<td>Clear</td>
<td><code>m.clear ()</code></td>
<td><code>m</code> is mutable.</td>
<td><code>void</code></td>
</tr>
<tr>
<td>Resize</td>
<td><code>m.resize (n1, n2)</code><br />
<code>m.resize (n1, n2, p)</code></td>
<td><code>m</code> is mutable.</td>
<td><code>void</code></td>
</tr>
</tbody>
</table>
<h4>Expression semantics</h4>
<p>Semantics of an expression is defined only where it differs
from, or is not defined in <a href=
"expression_concept.htm#matrix_expression">Matrix Expression</a> .</p>
<table border="1" summary="semantics">
<tbody>
<tr>
<th>Name</th>
<th>Expression</th>
<th>Precondition</th>
<th>Semantics</th>
<th>Postcondition</th>
</tr>
<tr>
<td>Sizing constructor</td>
<td><code>M m (n1, n2)</code></td>
<td><code>n1 &gt;= 0</code> and <code>n2 &gt;= 0</code></td>
<td>Allocates a matrix of <code>n1</code> rows and <code>n2</code>
columns.</td>
<td><code>m.size1 () == n1</code> and <code>m.size2 () ==
n2</code>.</td>
</tr>
<tr>
<td>Insert</td>
<td><code>m.insert_element (i, j, t)</code></td>
<td><code>0 &lt;= i &lt; m.size1 ()</code>,<br />
<code>0 &lt;= j &lt; m.size2 ()</code>and <code><br />
m (i, j)</code> is equal to <code>value_type (0)</code>.</td>
<td>A copy of <code>t</code> is inserted in <code>m</code>.</td>
<td><code>m (i, j)</code> is a copy of <code>t</code>.</td>
</tr>
<tr>
<td>Erase</td>
<td><code>m.erase (i, j)</code></td>
<td><code>0 &lt;= i &lt; m.size1 ()</code>and <code><br />
0 &lt;= j &lt; m.size2</code></td>
<td>Destroys the element <code>m (i, j)</code> and replaces it with
<code>value_type ()</code>.</td>
<td><code>m (i, j)</code> is a copy of <code>value_type
()</code>.</td>
</tr>
<tr>
<td>Clear</td>
<td><code>m.clear ()</code></td>
<td>&nbsp;</td>
<td>Equivalent to<br />
<code>for (i = 0; i &lt; m.size1 (); ++ i)</code><br />
&nbsp; <code>for (j = 0; j &lt; m.size2 (); ++ j)</code><br />
&nbsp; &nbsp; <code>m.erase (i, j);</code></td>
<td>&nbsp;</td>
</tr>
<tr>
<td>Resize</td>
<td><code>m.resize (n1, n2)
<br />
m.resize (n1, n2, p)
</code></td>
<td>&nbsp;</td>
<td>Reallocate the matrix so that it can hold <code>n1</code> rows
and <code>n2</code> columns.<br />
Erases or appends elements in order to bring the matrix to the
prescribed size. Appended elements are <code>value_type()</code>
copies.<br />
When <code>p == false</code> then existing elements are not preserved and elements will not appended as normal. Instead the matrix is in the same state as that after an equivalent sizing constructor.</td>
<td><code>m.size1 () == n1</code> and <code>m.size2 () == n2</code>.</td>
</tr>
</tbody>
</table>
<h4>Complexity guarantees</h4>
<p>The run-time complexity of the sizing constructor is quadratic
in the matrix's size.</p>
<p>The run-time complexity of insert_element and erase_element is specific for the
matrix.</p>
<p>The run-time complexity of resize is quadratic in the matrix's
size.</p>
<h4>Invariants</h4>
<h4>Models</h4>
<ul>
<li><code>matrix&lt;T&gt;</code> , <code>bounded_matrix&lt;T, M, N&gt;</code></li>
<li><code>identity_matrix&lt;T&gt;</code> , <code>zero_matrix&lt;T&gt;</code> , <code>scalar_matrix&lt;T&gt;</code></li>
<li><code>triangular_matrix&lt;T&gt;</code> , <code>symmetric_matrix&lt;T&gt;</code> , <code>banded_matrix&lt;T&gt;</code></li>
<li><code>mapped_matrix&lt;T&gt;</code> , <code>compressed_matrix</code> , <code>coordinate_matrix</code></li>
</ul>
<hr />
<p>Copyright (&copy;) 2000-2002 Joerg Walter, Mathias Koch<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: 24/06/2004</p>
</body>
</html>

View File

@ -1,218 +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 http-equiv="Content-Type" content=
"text/html; charset=us-ascii" />
<link href="ublas.css" type="text/css" />
<title>DenseVector Concept</title>
</head>
<body>
<h1><img src="../../../../boost.png" align="middle" />
DenseVector Concept</h1>
<h2>DenseVector</h2>
<h4>Description</h4>
<p>A dense-vector is a, exactly as the name says, a dense vector that is intended to behave well for linear algebra operations</p>
<h4>Refinement of</h4>
<p><a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a>, <a href="http://www.sgi.com/tech/stl/RandomAccessContainer.html">RandomAccessContainer</a> and <a href="expression_concept.htm#vector_expression">Vector Expression</a><a href="#footnote1">[1]</a>.</p>
<h4>Associated types</h4>
<p>In addition to the types defined by <a href="http://www.sgi.com/tech/stl/RandomAccessContainer.html">RandomAccessContainer</a> and <a href="expression_concept.htm#vector_expression">Vector Expression</a></p>
<table border="1" summary="types">
<tbody>
<tr>
<td>StorageArray</td>
<td>array_type</td>
<td>The type of underlying storage used to store the elements</td>
</tr>
</tbody>
</table>
<h4>Notation</h4>
<table border="0" summary="notation">
<tbody>
<tr>
<td><code>V</code></td>
<td>A type that is a model of Vector</td>
</tr>
<tr>
<td><code>T</code></td>
<td>The value_type of elements of V</td>
</tr>
<tr>
<td><code>v</code></td>
<td>Objects of type <code>V</code></td>
</tr>
<tr>
<td><code>n, i</code></td>
<td>Objects of a type convertible to <code>size_type</code></td>
</tr>
<tr>
<td><code>t</code></td>
<td>Object of a type convertible to <code>T</code></td>
</tr>
<tr>
<td><code>p</code></td>
<td>Object of a type convertible to <code>bool</code></td>
</tr>
</tbody>
</table>
<h4>Definitions</h4>
<h4>Valid expressions</h4>
<p>In addition to the expressions defined in <a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a> and <a href="expression_concept.htm#vector_expression">Vector Expression</a> the following expressions must be valid.</p>
<table border="1" summary="expressions">
<tbody>
<tr>
<th>Name</th>
<th>Expression</th>
<th>Type requirements</th>
<th>Return type</th>
</tr>
<tr>
<td>Size-constructor</td>
<td><code>V v(n)</code></td>
<td>T is <a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a></td>
<td><code>V</code></td>
</tr>
<tr>
<tr>
<td>Insert</td>
<td><code>v.insert_element (i, t)</code></td>
<td><code>v</code> is mutable.</td>
<td><code>void</code></td>
</tr>
<tr>
<td>Erase</td>
<td><code>v.erase_element (i)</code></td>
<td><code>v</code> is mutable.</td>
<td><code>void</code></td>
</tr>
<tr>
<td>Clear</td>
<td><code>v.clear ()</code></td>
<td><code>v</code> is mutable.</td>
<td><code>void</code></td>
</tr>
<tr>
<td>Resize</td>
<td><code>v.resize (n)</code><br />
<code>v.resize (n, p)</code></td>
<td><code>v</code> is mutable.</td>
<td><code>void</code></td>
</tr>
<tr>
<td>Storage</td>
<td><code>data() const</code></td>
<td></td>
<td><code>const array_type&amp;</code></td>
</tr>
<tr>
<td>Storage</td>
<td><code>data()</code></td>
<td><code>v</code> is mutable</td>
<td><code>array_type&amp;</code></td>
</tr>
</tbody>
</table>
<h4>Expression semantics</h4>
<p>Semantics of an expression is defined only where it differs
from, or is not defined in <a href=
"expression_concept.htm#vector_expression">Vector Expression</a> .</p>
<table border="1" summary="semantics">
<tr>
<th>Name</th>
<th>Expression</th>
<th>Precondition</th>
<th>Semantics</th>
<th>Postcondition</th>
</tr>
<tr>
<td>Sizing constructor</td>
<td><code>V v (n)</code></td>
<td><code>n &gt;= 0</code></td>
<td>Allocates a vector of<code>n</code> elements.</td>
<td><code>v.size () == n</code>.</td>
</tr>
<tr>
<td>Element access <a href="#element_access_note">[1]</a></td>
<td><code>v[n]</code></td>
<td><code>0&lt;n&gt;v.size()</code></td>
<td>returns the n-th element in v</td>
<td></td>
</tr>
<tr>
<td>Insert</td>
<td><code>v.insert_element (i, t)</code></td>
<td><code>0 &lt;= i &lt; v.size ()</code> and<br />
<code>v (i)</code> is equal to <code>value_type (0)</code>.</td>
<td>A copy of <code>t</code> is inserted in <code>v</code>.</td>
<td><code>v (i)</code> is a copy of <code>t</code>.</td>
</tr>
<tr>
<td>Erase</td>
<td><code>v.erase_element (i)</code></td>
<td><code>0 &lt;= i &lt; v.size ()</code></td>
<td>Destroys the element <code>v (i)</code> and replaces it with
<code>value_type ()</code>.</td>
<td><code>v (i)</code> is a copy of <code>value_type
()</code>.</td>
</tr>
<tr>
<td>Clear</td>
<td><code>v.clear ()</code></td>
<td>&nbsp;</td>
<td>Equivalent to<br />
<code>for (i = 0; i &lt; v.size (); ++ i)</code><br />
&nbsp; <code>v.erase (i);</code></td>
<td>&nbsp;</td>
</tr>
<tr>
<td>Resize</td>
<td><code>v.resize (n)
<br />v.resize (n, p)</code></td>
<td>&nbsp;</td>
<td>Reallocates the vector so that it can hold <code>n</code>
elements.<br />
Erases or appends elements in order to bring the vector to the prescribed size. Appended elements copies of <code>value_type()</code>.
<br />
When <code>p == false</code> then existing elements are not preserved and elements will not appended as normal. Instead the vector is in the same state as that after an equivalent sizing constructor.</td>
<td><code>v.size () == n</code>.</td>
</tr>
<tr>
<td>Storage</td>
<td><code>v.data()</code></td>
<td><code>v</code> is const</td>
<td>Returns a reference to the underlying storage</td>
<td></td>
</tr>
<tr>
<td>Storage</td>
<td><code>v.data()</code></td>
<td><code>v</code> is mutable</td>
<td>Returns a reference to the underlying storage</td>
<td></td>
</tr>
</table>
<h4>Complexity guarantees</h4>
<p>The run-time complexity of the sizing constructor is linear in
the vector's size.</p>
<p>The run-time complexity of insert_element and erase_element is specific for the
vector.</p>
<p>The run-time complexity of resize is linear in the vector's
size.</p>
<h4>Invariants</h4>
<h4>Models</h4>
<ul>
<li><code>vector&lt;T&gt;</code> , <code>bounded_vector&lt;T, N&gt;</code></li>
<li><code>unit_vector&lt;T&gt;</code> , <code>zero_vector&lt;T&gt;</code> , <code>scalar_vector&lt;T&gt;</code></li>
<li><code>mapped_vector&lt;T&gt;</code> , <code>compressed_vector</code> , <code>coordinate_vector</code></li>
</ul>
<h4>Notes</h4>
<p><a name="footnote1">[1]</a>
As a user you should not care about <tt>DenseVector</tt> being a refinement of the VectorExpression. Being a refinement of the VectorExpression is only important for the template-expression engine but not the user.
<a name="element_access_note">[1]</a>The <code>operator[]</code> is added purely for convenience
and compatibility with the <code>std::vector</code>. In uBLAS however,
generally <code>operator()</code> is used for indexing because this can be
used for both vectors and matrices.
</body>
</html>