<!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 http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<title>ublas: boost::numeric::ublas::vector&lt; T, A &gt; Class Template Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<link href="doxygen.css" rel="stylesheet" type="text/css"/>
</head>
<body>
<!-- Generated by Doxygen 1.6.1 -->
<div class="navigation" id="top">
  <div class="tabs">
    <ul>
      <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
      <li><a href="pages.html"><span>Related&nbsp;Pages</span></a></li>
      <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
      <li><a href="files.html"><span>Files</span></a></li>
    </ul>
  </div>
  <div class="tabs">
    <ul>
      <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
      <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
      <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
    </ul>
  </div>
  <div class="navpath"><b>boost</b>::<b>numeric</b>::<b>ublas</b>::<a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>
  </div>
</div>
<div class="contents">
<h1>boost::numeric::ublas::vector&lt; T, A &gt; Class Template Reference</h1><!-- doxytag: class="boost::numeric::ublas::vector" --><!-- doxytag: inherits="vector_container&lt; vector&lt; T, A &gt; &gt;" -->
<p>A dense <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> of values of type <code>T</code>.  
<a href="#_details">More...</a></p>

<p>Inherits <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__container.html">vector_container&lt; vector&lt; T, A &gt; &gt;</a>.</p>

<p>Inherited by <a class="el" href="classboost_1_1numeric_1_1ublas_1_1permutation__matrix.html">boost::numeric::ublas::permutation_matrix&lt; T, A &gt;</a>.</p>

<p><a href="classboost_1_1numeric_1_1ublas_1_1vector-members.html">List of all members.</a></p>
<table border="0" cellpadding="0" cellspacing="0">
<tr><td colspan="2"><h2>Classes</h2></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">class &nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1const__iterator.html">const_iterator</a></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">class &nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1iterator.html">iterator</a></td></tr>
<tr><td colspan="2"><h2>Public Types</h2></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a738b42501164c4bf04477aeb866f2928"></a><!-- doxytag: member="boost::numeric::ublas::vector::size_type" ref="a738b42501164c4bf04477aeb866f2928" args="" -->
typedef A::size_type&nbsp;</td><td class="memItemRight" valign="bottom"><b>size_type</b></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a30f565fa5b60bbd5be461cd944d70166"></a><!-- doxytag: member="boost::numeric::ublas::vector::difference_type" ref="a30f565fa5b60bbd5be461cd944d70166" args="" -->
typedef A::difference_type&nbsp;</td><td class="memItemRight" valign="bottom"><b>difference_type</b></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a676ded0b5b43617c292d2564eabd0040"></a><!-- doxytag: member="boost::numeric::ublas::vector::value_type" ref="a676ded0b5b43617c292d2564eabd0040" args="" -->
typedef T&nbsp;</td><td class="memItemRight" valign="bottom"><b>value_type</b></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="af22dff817d4a7b6366a1c525b2605d0a"></a><!-- doxytag: member="boost::numeric::ublas::vector::const_reference" ref="af22dff817d4a7b6366a1c525b2605d0a" args="" -->
typedef <a class="el" href="structboost_1_1numeric_1_1ublas_1_1type__traits.html">type_traits</a>&lt; T &gt;<br class="typebreak"/>
::const_reference&nbsp;</td><td class="memItemRight" valign="bottom"><b>const_reference</b></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a6aebdce7445c7a3fd99acfe776b786f7"></a><!-- doxytag: member="boost::numeric::ublas::vector::reference" ref="a6aebdce7445c7a3fd99acfe776b786f7" args="" -->
typedef T &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><b>reference</b></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a65d2d017e9a37d6f689b2dfb96998941"></a><!-- doxytag: member="boost::numeric::ublas::vector::pointer" ref="a65d2d017e9a37d6f689b2dfb96998941" args="" -->
typedef T *&nbsp;</td><td class="memItemRight" valign="bottom"><b>pointer</b></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="aed4961c84062e6300d2485181b005da7"></a><!-- doxytag: member="boost::numeric::ublas::vector::const_pointer" ref="aed4961c84062e6300d2485181b005da7" args="" -->
typedef const T *&nbsp;</td><td class="memItemRight" valign="bottom"><b>const_pointer</b></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a4b017fbba268675224aa85dbbd99d7d9"></a><!-- doxytag: member="boost::numeric::ublas::vector::array_type" ref="a4b017fbba268675224aa85dbbd99d7d9" args="" -->
typedef A&nbsp;</td><td class="memItemRight" valign="bottom"><b>array_type</b></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="aa719ce379bdca8d749dc45deb8dd40a4"></a><!-- doxytag: member="boost::numeric::ublas::vector::const_closure_type" ref="aa719ce379bdca8d749dc45deb8dd40a4" args="" -->
typedef const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__reference.html">vector_reference</a><br class="typebreak"/>
&lt; const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">self_type</a> &gt;&nbsp;</td><td class="memItemRight" valign="bottom"><b>const_closure_type</b></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="aeb2397308be8751c95e1d1f6d763ab8e"></a><!-- doxytag: member="boost::numeric::ublas::vector::closure_type" ref="aeb2397308be8751c95e1d1f6d763ab8e" args="" -->
typedef <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__reference.html">vector_reference</a><br class="typebreak"/>
&lt; <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">self_type</a> &gt;&nbsp;</td><td class="memItemRight" valign="bottom"><b>closure_type</b></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a02b06259c875aa24d930fbe49d4fa977"></a><!-- doxytag: member="boost::numeric::ublas::vector::vector_temporary_type" ref="a02b06259c875aa24d930fbe49d4fa977" args="" -->
typedef <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">self_type</a>&nbsp;</td><td class="memItemRight" valign="bottom"><b>vector_temporary_type</b></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a763f08245549e265ded4e36288c06839"></a><!-- doxytag: member="boost::numeric::ublas::vector::storage_category" ref="a763f08245549e265ded4e36288c06839" args="" -->
typedef <a class="el" href="structboost_1_1numeric_1_1ublas_1_1dense__tag.html">dense_tag</a>&nbsp;</td><td class="memItemRight" valign="bottom"><b>storage_category</b></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a85a7d4737407e5ec795ee955da94864d"></a><!-- doxytag: member="boost::numeric::ublas::vector::const_reverse_iterator" ref="a85a7d4737407e5ec795ee955da94864d" args="" -->
typedef reverse_iterator_base<br class="typebreak"/>
&lt; <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1const__iterator.html">const_iterator</a> &gt;&nbsp;</td><td class="memItemRight" valign="bottom"><b>const_reverse_iterator</b></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a19a09f65e5e981526e05b7a5b2a8bee9"></a><!-- doxytag: member="boost::numeric::ublas::vector::reverse_iterator" ref="a19a09f65e5e981526e05b7a5b2a8bee9" args="" -->
typedef reverse_iterator_base<br class="typebreak"/>
&lt; <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1iterator.html">iterator</a> &gt;&nbsp;</td><td class="memItemRight" valign="bottom"><b>reverse_iterator</b></td></tr>
<tr><td colspan="2"><h2>Public Member Functions</h2></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a477a17fb1a95d016e4465de7ae9f7bd0"></a><!-- doxytag: member="boost::numeric::ublas::vector::vector" ref="a477a17fb1a95d016e4465de7ae9f7bd0" args="()" -->
BOOST_UBLAS_INLINE&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a477a17fb1a95d016e4465de7ae9f7bd0">vector</a> ()</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Constructor of a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> By default it is empty, i.e. <code><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a1b9ef7522219d74ebd27bab25e4b6841" title="Return the size of the vector.">size()</a>==0</code>. <br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#ae75b77993f678047c69b985f8450edc0">vector</a> (size_type size)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Constructor of a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> with a predefined size By default, its elements are initialized to 0.  <a href="#ae75b77993f678047c69b985f8450edc0"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#aa2cdc17765d1689ac52d261dcc123724">vector</a> (size_type size, const array_type &amp;data)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Constructor of a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> by copying from another container This type has the generic name <code>array_typ</code> within the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> definition.  <a href="#aa2cdc17765d1689ac52d261dcc123724"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a2c095b29597c40a1695c26486f34edba">vector</a> (const array_type &amp;data)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Constructor of a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> by copying from another container This type has the generic name <code>array_typ</code> within the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> definition.  <a href="#a2c095b29597c40a1695c26486f34edba"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a812bdffb89c10f69cc9af3963cfb02ea">vector</a> (size_type size, const value_type &amp;init)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Constructor of a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> with a predefined size and a unique initial value.  <a href="#a812bdffb89c10f69cc9af3963cfb02ea"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a18dae81ff4bcd46986e99f58764e773b">vector</a> (const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;v)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Copy-constructor of a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>.  <a href="#a18dae81ff4bcd46986e99f58764e773b"></a><br/></td></tr>
<tr><td class="memTemplParams" colspan="2">template&lt;class AE &gt; </td></tr>
<tr><td class="memTemplItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE&nbsp;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a7b0b649369be331ad80513f220b086dc">vector</a> (const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html">vector_expression</a>&lt; AE &gt; &amp;ae)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Copy-constructor of a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> from a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> Depending on the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a>, this constructor can have the cost of the computations of the expression (trivial to say it, but it is to take into account in your complexity calculations).  <a href="#a7b0b649369be331ad80513f220b086dc"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a40757a37ac3ad92fc89895a200ac5de3"></a><!-- doxytag: member="boost::numeric::ublas::vector::max_size" ref="a40757a37ac3ad92fc89895a200ac5de3" args="() const " -->
BOOST_UBLAS_INLINE size_type&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a40757a37ac3ad92fc89895a200ac5de3">max_size</a> () const </td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return the maximum size of the data container. Return the upper bound (maximum size) on the data container. Depending on the container, it can be bigger than the current size of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>. <br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE bool&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a5ca7b44d2563752edcd0cc0ad5f2113c">empty</a> () const </td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return true if the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> is empty (<code>size==0</code>).  <a href="#a5ca7b44d2563752edcd0cc0ad5f2113c"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a1b9ef7522219d74ebd27bab25e4b6841"></a><!-- doxytag: member="boost::numeric::ublas::vector::size" ref="a1b9ef7522219d74ebd27bab25e4b6841" args="() const " -->
BOOST_UBLAS_INLINE size_type&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a1b9ef7522219d74ebd27bab25e4b6841">size</a> () const </td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return the size of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>. <br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a941dea529f7d464d5f044657528c4922"></a><!-- doxytag: member="boost::numeric::ublas::vector::data" ref="a941dea529f7d464d5f044657528c4922" args="() const " -->
BOOST_UBLAS_INLINE const <br class="typebreak"/>
array_type &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a941dea529f7d464d5f044657528c4922">data</a> () const </td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return a <code>const</code> reference to the container. Useful to access data directly for specific type of container. <br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a2fa457a2e17d4a1b56730078a9eed38f"></a><!-- doxytag: member="boost::numeric::ublas::vector::data" ref="a2fa457a2e17d4a1b56730078a9eed38f" args="()" -->
BOOST_UBLAS_INLINE array_type &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a2fa457a2e17d4a1b56730078a9eed38f">data</a> ()</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return a reference to the container. Useful to speed-up write operations to the data in very specific case. <br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a113118def88db3755da6690b6ec903f0">resize</a> (size_type size, bool preserve=true)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Resize the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> Resize the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> to a new size. If <code>preserve</code> is true, data are copied otherwise data are lost. If the new size is bigger, the remaining values are filled in with the initial value (0 by default) in the case of <code><a class="el" href="classboost_1_1numeric_1_1ublas_1_1unbounded__array.html">unbounded_array</a></code>, which is the container by default. If the new size is smaller, last values are lost. This behaviour can be different if you explicitely specify another type of container.  <a href="#a113118def88db3755da6690b6ec903f0"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE pointer&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a0ad6b2bb8196fc36e33d3aa47d296500">find_element</a> (size_type i)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return a pointer to the element <img class="formulaInl" alt="$i$" src="form_69.png"/>.  <a href="#a0ad6b2bb8196fc36e33d3aa47d296500"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE const_pointer&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a5b1de2ac98f634b04640bcea98fe8298">find_element</a> (size_type i) const </td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return a const pointer to the element <img class="formulaInl" alt="$i$" src="form_69.png"/>.  <a href="#a5b1de2ac98f634b04640bcea98fe8298"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE const_reference&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#aa511fcff4d8dba52bf163fbc9664dfbf">operator()</a> (size_type i) const </td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return a const reference to the element <img class="formulaInl" alt="$i$" src="form_69.png"/> Return a const reference to the element <img class="formulaInl" alt="$i$" src="form_69.png"/>. With some compilers, this notation will be faster than <code></code>[i].  <a href="#aa511fcff4d8dba52bf163fbc9664dfbf"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE reference&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a4b53f6b15f6aaa81b059bbdcaaf00fab">operator()</a> (size_type i)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return a reference to the element <img class="formulaInl" alt="$i$" src="form_69.png"/> Return a reference to the element <img class="formulaInl" alt="$i$" src="form_69.png"/>. With some compilers, this notation will be faster than <code></code>[i].  <a href="#a4b53f6b15f6aaa81b059bbdcaaf00fab"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE const_reference&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a0cfc171dac4e78549a96c43062a052c6">operator[]</a> (size_type i) const </td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return a const reference to the element <img class="formulaInl" alt="$i$" src="form_69.png"/>.  <a href="#a0cfc171dac4e78549a96c43062a052c6"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE reference&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a10b3c5c3a5042f21a996eeb75c447529">operator[]</a> (size_type i)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return a reference to the element <img class="formulaInl" alt="$i$" src="form_69.png"/>.  <a href="#a10b3c5c3a5042f21a996eeb75c447529"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE reference&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a35b8f3eae165e33d8d4e33f86f40b954">insert_element</a> (size_type i, const_reference t)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Set element <img class="formulaInl" alt="$i$" src="form_69.png"/> to the value <code>t</code>.  <a href="#a35b8f3eae165e33d8d4e33f86f40b954"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#ac3700c206fa1bf8e5205edbb859432c1">erase_element</a> (size_type i)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Set element <img class="formulaInl" alt="$i$" src="form_69.png"/> to the <em>zero</em> value.  <a href="#ac3700c206fa1bf8e5205edbb859432c1"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="aad56668044d71db97be9e44db273f09a"></a><!-- doxytag: member="boost::numeric::ublas::vector::clear" ref="aad56668044d71db97be9e44db273f09a" args="()" -->
BOOST_UBLAS_INLINE void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#aad56668044d71db97be9e44db273f09a">clear</a> ()</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Clear the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>, i.e. set all values to the <code>zero</code> value. <br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a1724d353e3006619a995342bc6be134e">operator=</a> (const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;v)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Assign a full <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> (<em>RHS-vector</em>) to the current <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> (<em>LHS-vector</em>).  <a href="#a1724d353e3006619a995342bc6be134e"></a><br/></td></tr>
<tr><td class="memTemplParams" colspan="2">template&lt;class C &gt; </td></tr>
<tr><td class="memTemplItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;&nbsp;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#af778c9aad1d18346fe2ec22642454755">operator=</a> (const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__container.html">vector_container</a>&lt; C &gt; &amp;v)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Assign a full <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> (<em>RHS-vector</em>) to the current <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> (<em>LHS-vector</em>) Assign a full <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> (<em>RHS-vector</em>) to the current <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> (<em>LHS-vector</em>). This method does not create any temporary.  <a href="#af778c9aad1d18346fe2ec22642454755"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a2ece9f4455a3a98e4ab98d131d440f85">assign_temporary</a> (<a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;v)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Assign a full <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> (<em>RHS-vector</em>) to the current <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> (<em>LHS-vector</em>).  <a href="#a2ece9f4455a3a98e4ab98d131d440f85"></a><br/></td></tr>
<tr><td class="memTemplParams" colspan="2">template&lt;class AE &gt; </td></tr>
<tr><td class="memTemplItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;&nbsp;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#af7df90fe154185ba4688750a8acc0c68">operator=</a> (const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html">vector_expression</a>&lt; AE &gt; &amp;ae)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Assign the result of a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> Assign the result of a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>. This is lazy-compiled and will be optimized out by the compiler on any type of expression.  <a href="#af7df90fe154185ba4688750a8acc0c68"></a><br/></td></tr>
<tr><td class="memTemplParams" colspan="2">template&lt;class AE &gt; </td></tr>
<tr><td class="memTemplItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;&nbsp;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a449aa3da7748032b856c4ad74549f14d">assign</a> (const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html">vector_expression</a>&lt; AE &gt; &amp;ae)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Assign the result of a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> Assign the result of a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>. This is lazy-compiled and will be optimized out by the compiler on any type of expression.  <a href="#a449aa3da7748032b856c4ad74549f14d"></a><br/></td></tr>
<tr><td class="memTemplParams" colspan="2">template&lt;class AE &gt; </td></tr>
<tr><td class="memTemplItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;&nbsp;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a9ec4c7260a33c9ad841339b4f59aa73b">operator+=</a> (const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html">vector_expression</a>&lt; AE &gt; &amp;ae)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Assign the sum of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> and a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> Assign the sum of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> and a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>. This is lazy-compiled and will be optimized out by the compiler on any type of expression. A temporary is created for the computations.  <a href="#a9ec4c7260a33c9ad841339b4f59aa73b"></a><br/></td></tr>
<tr><td class="memTemplParams" colspan="2">template&lt;class C &gt; </td></tr>
<tr><td class="memTemplItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;&nbsp;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a953fa9e2fa2e610674e5f94391f60333">operator+=</a> (const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__container.html">vector_container</a>&lt; C &gt; &amp;v)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Assign the sum of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> and a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> Assign the sum of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> and a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>.  <a href="#a953fa9e2fa2e610674e5f94391f60333"></a><br/></td></tr>
<tr><td class="memTemplParams" colspan="2">template&lt;class AE &gt; </td></tr>
<tr><td class="memTemplItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;&nbsp;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#afd874b1ba7fe6a5b961cc3b228cd1208">plus_assign</a> (const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html">vector_expression</a>&lt; AE &gt; &amp;ae)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Assign the sum of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> and a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> Assign the sum of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> and a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>.  <a href="#afd874b1ba7fe6a5b961cc3b228cd1208"></a><br/></td></tr>
<tr><td class="memTemplParams" colspan="2">template&lt;class AE &gt; </td></tr>
<tr><td class="memTemplItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;&nbsp;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a74138b9c59c7dee5d4cfea50359efaa3">operator-=</a> (const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html">vector_expression</a>&lt; AE &gt; &amp;ae)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Assign the difference of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> and a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> Assign the difference of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> and a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>. This is lazy-compiled and will be optimized out by the compiler on any type of expression. A temporary is created for the computations.  <a href="#a74138b9c59c7dee5d4cfea50359efaa3"></a><br/></td></tr>
<tr><td class="memTemplParams" colspan="2">template&lt;class C &gt; </td></tr>
<tr><td class="memTemplItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;&nbsp;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a04918781e246fb21d1fb0f36948c04fb">operator-=</a> (const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__container.html">vector_container</a>&lt; C &gt; &amp;v)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Assign the difference of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> and a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> Assign the difference of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> and a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>.  <a href="#a04918781e246fb21d1fb0f36948c04fb"></a><br/></td></tr>
<tr><td class="memTemplParams" colspan="2">template&lt;class AE &gt; </td></tr>
<tr><td class="memTemplItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;&nbsp;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#ac02f6ccd9710c186f9ae734e6395b742">minus_assign</a> (const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html">vector_expression</a>&lt; AE &gt; &amp;ae)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Assign the difference of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> and a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> Assign the difference of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> and a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>.  <a href="#ac02f6ccd9710c186f9ae734e6395b742"></a><br/></td></tr>
<tr><td class="memTemplParams" colspan="2">template&lt;class AT &gt; </td></tr>
<tr><td class="memTemplItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;&nbsp;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a6cee4bffbd0981075d11f4e7fc5e04d2">operator*=</a> (const AT &amp;at)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Assign the product of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> and a scalar to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> Assign the product of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> and a scalar to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>.  <a href="#a6cee4bffbd0981075d11f4e7fc5e04d2"></a><br/></td></tr>
<tr><td class="memTemplParams" colspan="2">template&lt;class AT &gt; </td></tr>
<tr><td class="memTemplItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;&nbsp;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a6800b804a49a7bd4ce3767d1ea0aafc0">operator/=</a> (const AT &amp;at)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Assign the division of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> by a scalar to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> Assign the division of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> by a scalar to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>. This is lazy-compiled and will be optimized out by the compiler on any type of expression. No temporary is created. Computations are done and stored directly into the resulting <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>.  <a href="#a6800b804a49a7bd4ce3767d1ea0aafc0"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#aedce8a2ea66b86b1e3efb21bba7be0c5">swap</a> (<a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;v)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Swap the content of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> with another <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>.  <a href="#aedce8a2ea66b86b1e3efb21bba7be0c5"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1const__iterator.html">const_iterator</a>&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a3be04f746cfe32f0de3aaa2a5273f3a1">find</a> (size_type i) const </td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return a const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1iterator.html">iterator</a> to the element <em>i</em>.  <a href="#a3be04f746cfe32f0de3aaa2a5273f3a1"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1iterator.html">iterator</a>&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#ac7ed001baef390b605d6b932a055e5f3">find</a> (size_type i)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return an <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1iterator.html">iterator</a> to the element <em>i</em>.  <a href="#ac7ed001baef390b605d6b932a055e5f3"></a><br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a3737e9b662f9ba10fa87789de4fa37f6"></a><!-- doxytag: member="boost::numeric::ublas::vector::begin" ref="a3737e9b662f9ba10fa87789de4fa37f6" args="() const " -->
BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1const__iterator.html">const_iterator</a>&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a3737e9b662f9ba10fa87789de4fa37f6">begin</a> () const </td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">return an <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1iterator.html">iterator</a> on the first element of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> <br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a0bde39bb3dac56f1c0c8cc6e044942ab"></a><!-- doxytag: member="boost::numeric::ublas::vector::end" ref="a0bde39bb3dac56f1c0c8cc6e044942ab" args="() const " -->
BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1const__iterator.html">const_iterator</a>&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a0bde39bb3dac56f1c0c8cc6e044942ab">end</a> () const </td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">return an <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1iterator.html">iterator</a> after the last element of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> <br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a3160d419e77bfd6fe805e4a70cbf882b"></a><!-- doxytag: member="boost::numeric::ublas::vector::begin" ref="a3160d419e77bfd6fe805e4a70cbf882b" args="()" -->
BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1iterator.html">iterator</a>&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a3160d419e77bfd6fe805e4a70cbf882b">begin</a> ()</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return an <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1iterator.html">iterator</a> on the first element of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>. <br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="afdb08490029b3d55cdec200d665bfa04"></a><!-- doxytag: member="boost::numeric::ublas::vector::end" ref="afdb08490029b3d55cdec200d665bfa04" args="()" -->
BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1iterator.html">iterator</a>&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#afdb08490029b3d55cdec200d665bfa04">end</a> ()</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return an <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1iterator.html">iterator</a> at the end of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>. <br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a1860dd32b80e7418fbf49fe7b99f6012"></a><!-- doxytag: member="boost::numeric::ublas::vector::rbegin" ref="a1860dd32b80e7418fbf49fe7b99f6012" args="() const " -->
BOOST_UBLAS_INLINE <br class="typebreak"/>
const_reverse_iterator&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a1860dd32b80e7418fbf49fe7b99f6012">rbegin</a> () const </td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return a const reverse <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1iterator.html">iterator</a> before the first element of the reversed <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> (i.e. <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#afdb08490029b3d55cdec200d665bfa04" title="Return an iterator at the end of the vector.">end()</a> of normal <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>). <br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a0098add795c37e4d67f6f98436e1aac8"></a><!-- doxytag: member="boost::numeric::ublas::vector::rend" ref="a0098add795c37e4d67f6f98436e1aac8" args="() const " -->
BOOST_UBLAS_INLINE <br class="typebreak"/>
const_reverse_iterator&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a0098add795c37e4d67f6f98436e1aac8">rend</a> () const </td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return a const reverse <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1iterator.html">iterator</a> on the end of the reverse <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> (i.e. first element of the normal <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>). <br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a1595a26c1f668988af4a8bbe86ae4ed4"></a><!-- doxytag: member="boost::numeric::ublas::vector::rbegin" ref="a1595a26c1f668988af4a8bbe86ae4ed4" args="()" -->
BOOST_UBLAS_INLINE reverse_iterator&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a1595a26c1f668988af4a8bbe86ae4ed4">rbegin</a> ()</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return a const reverse <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1iterator.html">iterator</a> before the first element of the reversed <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> (i.e. <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#afdb08490029b3d55cdec200d665bfa04" title="Return an iterator at the end of the vector.">end()</a> of normal <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>). <br/></td></tr>
<tr><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a423d1dc8dbf20b2180093a504dea0ea2"></a><!-- doxytag: member="boost::numeric::ublas::vector::rend" ref="a423d1dc8dbf20b2180093a504dea0ea2" args="()" -->
BOOST_UBLAS_INLINE reverse_iterator&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a423d1dc8dbf20b2180093a504dea0ea2">rend</a> ()</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Return a const reverse <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1iterator.html">iterator</a> on the end of the reverse <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> (i.e. first element of the normal <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>). <br/></td></tr>
<tr><td class="memTemplParams" colspan="2">template&lt;class Archive &gt; </td></tr>
<tr><td class="memTemplItemLeft" align="right" valign="top">void&nbsp;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a44062e23411cf30e80dd25d500cdfe2e">serialize</a> (Archive &amp;ar, const unsigned int)</td></tr>
<tr><td colspan="2"><h2>Friends</h2></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">BOOST_UBLAS_INLINE friend void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html#a7ec2565da7f04f5f8ba42785be772df7">swap</a> (<a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;v1, <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> &amp;v2)</td></tr>
<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Swap the content of two vectors.  <a href="#a7ec2565da7f04f5f8ba42785be772df7"></a><br/></td></tr>
</table>
<hr/><a name="_details"></a><h2>Detailed Description</h2>
<h3>template&lt;class T, class A&gt;<br/>
 class boost::numeric::ublas::vector&lt; T, A &gt;</h3>

<p>For a <img class="formulaInl" alt="$n$" src="form_66.png"/>-dimensional <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> <img class="formulaInl" alt="$v$" src="form_20.png"/> and <img class="formulaInl" alt="$0\leq i < n$" src="form_67.png"/> every element <img class="formulaInl" alt="$v_i$" src="form_68.png"/> is mapped to the <img class="formulaInl" alt="$i$" src="form_69.png"/>-th element of the container. A storage type <code>A</code> can be specified which defaults to <code><a class="el" href="classboost_1_1numeric_1_1ublas_1_1unbounded__array.html">unbounded_array</a></code>. Elements are constructed by <code>A</code>, which need not initialise their value.</p>
<dl><dt><b>Template Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>T</em>&nbsp;</td><td>type of the objects stored in the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> (like int, double, complex,...) </td></tr>
    <tr><td valign="top"></td><td valign="top"><em>A</em>&nbsp;</td><td>The type of the storage array of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>. Default is <code>unbounded_array&lt;T&gt;</code>. <code>&lt;bounded_array&lt;T&gt;</code> and <code>std::vector&lt;T&gt;</code> can also be used </td></tr>
  </table>
  </dd>
</dl>
<hr/><h2>Constructor &amp; Destructor Documentation</h2>
<a class="anchor" id="ae75b77993f678047c69b985f8450edc0"></a><!-- doxytag: member="boost::numeric::ublas::vector::vector" ref="ae75b77993f678047c69b985f8450edc0" args="(size_type size)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::<a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> </td>
          <td>(</td>
          <td class="paramtype">size_type&nbsp;</td>
          <td class="paramname"> <em>size</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td><code> [explicit]</code></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>size</em>&nbsp;</td><td>initial size of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="aa2cdc17765d1689ac52d261dcc123724"></a><!-- doxytag: member="boost::numeric::ublas::vector::vector" ref="aa2cdc17765d1689ac52d261dcc123724" args="(size_type size, const array_type &amp;data)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::<a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> </td>
          <td>(</td>
          <td class="paramtype">size_type&nbsp;</td>
          <td class="paramname"> <em>size</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const array_type &amp;&nbsp;</td>
          <td class="paramname"> <em>data</em></td><td>&nbsp;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>size</em>&nbsp;</td><td>initial size of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> </td></tr>
    <tr><td valign="top"></td><td valign="top"><em>data</em>&nbsp;</td><td>container of type <code>A</code> </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a2c095b29597c40a1695c26486f34edba"></a><!-- doxytag: member="boost::numeric::ublas::vector::vector" ref="a2c095b29597c40a1695c26486f34edba" args="(const array_type &amp;data)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::<a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> </td>
          <td>(</td>
          <td class="paramtype">const array_type &amp;&nbsp;</td>
          <td class="paramname"> <em>data</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>data</em>&nbsp;</td><td>container of type <code>A</code> </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a812bdffb89c10f69cc9af3963cfb02ea"></a><!-- doxytag: member="boost::numeric::ublas::vector::vector" ref="a812bdffb89c10f69cc9af3963cfb02ea" args="(size_type size, const value_type &amp;init)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::<a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> </td>
          <td>(</td>
          <td class="paramtype">size_type&nbsp;</td>
          <td class="paramname"> <em>size</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const value_type &amp;&nbsp;</td>
          <td class="paramname"> <em>init</em></td><td>&nbsp;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>size</em>&nbsp;</td><td>of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> </td></tr>
    <tr><td valign="top"></td><td valign="top"><em>init</em>&nbsp;</td><td>value to assign to each element of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a18dae81ff4bcd46986e99f58764e773b"></a><!-- doxytag: member="boost::numeric::ublas::vector::vector" ref="a18dae81ff4bcd46986e99f58764e773b" args="(const vector &amp;v)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::<a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> </td>
          <td>(</td>
          <td class="paramtype">const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&lt; T, A &gt; &amp;&nbsp;</td>
          <td class="paramname"> <em>v</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>v</em>&nbsp;</td><td>is the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> to be duplicated </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a7b0b649369be331ad80513f220b086dc"></a><!-- doxytag: member="boost::numeric::ublas::vector::vector" ref="a7b0b649369be331ad80513f220b086dc" args="(const vector_expression&lt; AE &gt; &amp;ae)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
<div class="memtemplate">
template&lt;class AE &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::<a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a> </td>
          <td>(</td>
          <td class="paramtype">const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html">vector_expression</a>&lt; AE &gt; &amp;&nbsp;</td>
          <td class="paramname"> <em>ae</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>ae</em>&nbsp;</td><td>the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> which values will be duplicated into the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<hr/><h2>Member Function Documentation</h2>
<a class="anchor" id="a449aa3da7748032b856c4ad74549f14d"></a><!-- doxytag: member="boost::numeric::ublas::vector::assign" ref="a449aa3da7748032b856c4ad74549f14d" args="(const vector_expression&lt; AE &gt; &amp;ae)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
<div class="memtemplate">
template&lt;class AE &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&amp; <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::assign </td>
          <td>(</td>
          <td class="paramtype">const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html">vector_expression</a>&lt; AE &gt; &amp;&nbsp;</td>
          <td class="paramname"> <em>ae</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Template Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>AE</em>&nbsp;</td><td>is the type of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>ae</em>&nbsp;</td><td>is a const reference to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>a reference to the resulting <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> </dd></dl>

</div>
</div>
<a class="anchor" id="a2ece9f4455a3a98e4ab98d131d440f85"></a><!-- doxytag: member="boost::numeric::ublas::vector::assign_temporary" ref="a2ece9f4455a3a98e4ab98d131d440f85" args="(vector &amp;v)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&amp; <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::assign_temporary </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&lt; T, A &gt; &amp;&nbsp;</td>
          <td class="paramname"> <em>v</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>v</em>&nbsp;</td><td>is the source <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>a reference to a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> (i.e. the destination <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>) </dd></dl>

</div>
</div>
<a class="anchor" id="a5ca7b44d2563752edcd0cc0ad5f2113c"></a><!-- doxytag: member="boost::numeric::ublas::vector::empty" ref="a5ca7b44d2563752edcd0cc0ad5f2113c" args="() const " -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE bool <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::empty </td>
          <td>(</td>
          <td class="paramname"></td>
          <td>&nbsp;)&nbsp;</td>
          <td> const</td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl class="return"><dt><b>Returns:</b></dt><dd><code>true</code> if empty, <code>false</code> otherwise </dd></dl>

</div>
</div>
<a class="anchor" id="ac3700c206fa1bf8e5205edbb859432c1"></a><!-- doxytag: member="boost::numeric::ublas::vector::erase_element" ref="ac3700c206fa1bf8e5205edbb859432c1" args="(size_type i)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE void <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::erase_element </td>
          <td>(</td>
          <td class="paramtype">size_type&nbsp;</td>
          <td class="paramname"> <em>i</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>i</em>&nbsp;</td><td>index of the element </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ac7ed001baef390b605d6b932a055e5f3"></a><!-- doxytag: member="boost::numeric::ublas::vector::find" ref="ac7ed001baef390b605d6b932a055e5f3" args="(size_type i)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1iterator.html">iterator</a> <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::find </td>
          <td>(</td>
          <td class="paramtype">size_type&nbsp;</td>
          <td class="paramname"> <em>i</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>i</em>&nbsp;</td><td>index of the element </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a3be04f746cfe32f0de3aaa2a5273f3a1"></a><!-- doxytag: member="boost::numeric::ublas::vector::find" ref="a3be04f746cfe32f0de3aaa2a5273f3a1" args="(size_type i) const " -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector_1_1const__iterator.html">const_iterator</a> <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::find </td>
          <td>(</td>
          <td class="paramtype">size_type&nbsp;</td>
          <td class="paramname"> <em>i</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td> const</td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>i</em>&nbsp;</td><td>index of the element </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a5b1de2ac98f634b04640bcea98fe8298"></a><!-- doxytag: member="boost::numeric::ublas::vector::find_element" ref="a5b1de2ac98f634b04640bcea98fe8298" args="(size_type i) const " -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE const_pointer <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::find_element </td>
          <td>(</td>
          <td class="paramtype">size_type&nbsp;</td>
          <td class="paramname"> <em>i</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td> const</td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>i</em>&nbsp;</td><td>index of the element </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a0ad6b2bb8196fc36e33d3aa47d296500"></a><!-- doxytag: member="boost::numeric::ublas::vector::find_element" ref="a0ad6b2bb8196fc36e33d3aa47d296500" args="(size_type i)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE pointer <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::find_element </td>
          <td>(</td>
          <td class="paramtype">size_type&nbsp;</td>
          <td class="paramname"> <em>i</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>i</em>&nbsp;</td><td>index of the element </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a35b8f3eae165e33d8d4e33f86f40b954"></a><!-- doxytag: member="boost::numeric::ublas::vector::insert_element" ref="a35b8f3eae165e33d8d4e33f86f40b954" args="(size_type i, const_reference t)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE reference <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::insert_element </td>
          <td>(</td>
          <td class="paramtype">size_type&nbsp;</td>
          <td class="paramname"> <em>i</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const_reference&nbsp;</td>
          <td class="paramname"> <em>t</em></td><td>&nbsp;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>i</em>&nbsp;</td><td>index of the element </td></tr>
    <tr><td valign="top"></td><td valign="top"><em>t</em>&nbsp;</td><td>reference to the value to be set </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ac02f6ccd9710c186f9ae734e6395b742"></a><!-- doxytag: member="boost::numeric::ublas::vector::minus_assign" ref="ac02f6ccd9710c186f9ae734e6395b742" args="(const vector_expression&lt; AE &gt; &amp;ae)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
<div class="memtemplate">
template&lt;class AE &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&amp; <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::minus_assign </td>
          <td>(</td>
          <td class="paramtype">const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html">vector_expression</a>&lt; AE &gt; &amp;&nbsp;</td>
          <td class="paramname"> <em>ae</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Template Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>AE</em>&nbsp;</td><td>is the type of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>ae</em>&nbsp;</td><td>is a const reference to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>a reference to the resulting <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> </dd></dl>

</div>
</div>
<a class="anchor" id="a4b53f6b15f6aaa81b059bbdcaaf00fab"></a><!-- doxytag: member="boost::numeric::ublas::vector::operator()" ref="a4b53f6b15f6aaa81b059bbdcaaf00fab" args="(size_type i)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE reference <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::operator() </td>
          <td>(</td>
          <td class="paramtype">size_type&nbsp;</td>
          <td class="paramname"> <em>i</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>i</em>&nbsp;</td><td>index of the element </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="aa511fcff4d8dba52bf163fbc9664dfbf"></a><!-- doxytag: member="boost::numeric::ublas::vector::operator()" ref="aa511fcff4d8dba52bf163fbc9664dfbf" args="(size_type i) const " -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE const_reference <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::operator() </td>
          <td>(</td>
          <td class="paramtype">size_type&nbsp;</td>
          <td class="paramname"> <em>i</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td> const</td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>i</em>&nbsp;</td><td>index of the element </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a6cee4bffbd0981075d11f4e7fc5e04d2"></a><!-- doxytag: member="boost::numeric::ublas::vector::operator*=" ref="a6cee4bffbd0981075d11f4e7fc5e04d2" args="(const AT &amp;at)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
<div class="memtemplate">
template&lt;class AT &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&amp; <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::operator*= </td>
          <td>(</td>
          <td class="paramtype">const AT &amp;&nbsp;</td>
          <td class="paramname"> <em>at</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Template Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>AE</em>&nbsp;</td><td>is the type of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>at</em>&nbsp;</td><td>is a const reference to the scalar </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>a reference to the resulting <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> </dd></dl>

</div>
</div>
<a class="anchor" id="a953fa9e2fa2e610674e5f94391f60333"></a><!-- doxytag: member="boost::numeric::ublas::vector::operator+=" ref="a953fa9e2fa2e610674e5f94391f60333" args="(const vector_container&lt; C &gt; &amp;v)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
<div class="memtemplate">
template&lt;class C &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&amp; <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::operator+= </td>
          <td>(</td>
          <td class="paramtype">const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__container.html">vector_container</a>&lt; C &gt; &amp;&nbsp;</td>
          <td class="paramname"> <em>v</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Template Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>AE</em>&nbsp;</td><td>is the type of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>ae</em>&nbsp;</td><td>is a const reference to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>a reference to the resulting <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> </dd></dl>

</div>
</div>
<a class="anchor" id="a9ec4c7260a33c9ad841339b4f59aa73b"></a><!-- doxytag: member="boost::numeric::ublas::vector::operator+=" ref="a9ec4c7260a33c9ad841339b4f59aa73b" args="(const vector_expression&lt; AE &gt; &amp;ae)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
<div class="memtemplate">
template&lt;class AE &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&amp; <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::operator+= </td>
          <td>(</td>
          <td class="paramtype">const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html">vector_expression</a>&lt; AE &gt; &amp;&nbsp;</td>
          <td class="paramname"> <em>ae</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Template Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>AE</em>&nbsp;</td><td>is the type of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>ae</em>&nbsp;</td><td>is a const reference to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>a reference to the resulting <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> </dd></dl>

</div>
</div>
<a class="anchor" id="a04918781e246fb21d1fb0f36948c04fb"></a><!-- doxytag: member="boost::numeric::ublas::vector::operator&#45;=" ref="a04918781e246fb21d1fb0f36948c04fb" args="(const vector_container&lt; C &gt; &amp;v)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
<div class="memtemplate">
template&lt;class C &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&amp; <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::operator-= </td>
          <td>(</td>
          <td class="paramtype">const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__container.html">vector_container</a>&lt; C &gt; &amp;&nbsp;</td>
          <td class="paramname"> <em>v</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Template Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>AE</em>&nbsp;</td><td>is the type of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>ae</em>&nbsp;</td><td>is a const reference to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>a reference to the resulting <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> </dd></dl>

</div>
</div>
<a class="anchor" id="a74138b9c59c7dee5d4cfea50359efaa3"></a><!-- doxytag: member="boost::numeric::ublas::vector::operator&#45;=" ref="a74138b9c59c7dee5d4cfea50359efaa3" args="(const vector_expression&lt; AE &gt; &amp;ae)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
<div class="memtemplate">
template&lt;class AE &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&amp; <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::operator-= </td>
          <td>(</td>
          <td class="paramtype">const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html">vector_expression</a>&lt; AE &gt; &amp;&nbsp;</td>
          <td class="paramname"> <em>ae</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Template Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>AE</em>&nbsp;</td><td>is the type of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>ae</em>&nbsp;</td><td>is a const reference to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a6800b804a49a7bd4ce3767d1ea0aafc0"></a><!-- doxytag: member="boost::numeric::ublas::vector::operator/=" ref="a6800b804a49a7bd4ce3767d1ea0aafc0" args="(const AT &amp;at)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
<div class="memtemplate">
template&lt;class AT &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&amp; <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::operator/= </td>
          <td>(</td>
          <td class="paramtype">const AT &amp;&nbsp;</td>
          <td class="paramname"> <em>at</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Template Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>AE</em>&nbsp;</td><td>is the type of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>at</em>&nbsp;</td><td>is a const reference to the scalar </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>a reference to the resulting <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> </dd></dl>

</div>
</div>
<a class="anchor" id="af7df90fe154185ba4688750a8acc0c68"></a><!-- doxytag: member="boost::numeric::ublas::vector::operator=" ref="af7df90fe154185ba4688750a8acc0c68" args="(const vector_expression&lt; AE &gt; &amp;ae)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
<div class="memtemplate">
template&lt;class AE &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&amp; <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::operator= </td>
          <td>(</td>
          <td class="paramtype">const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html">vector_expression</a>&lt; AE &gt; &amp;&nbsp;</td>
          <td class="paramname"> <em>ae</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Template Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>AE</em>&nbsp;</td><td>is the type of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>ae</em>&nbsp;</td><td>is a const reference to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>a reference to the resulting <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> </dd></dl>

<p>Reimplemented in <a class="el" href="classboost_1_1numeric_1_1ublas_1_1bounded__vector.html#a4d152b88addf11aa2754b3a24f46ba86">boost::numeric::ublas::bounded_vector&lt; T, N &gt;</a>.</p>

</div>
</div>
<a class="anchor" id="af778c9aad1d18346fe2ec22642454755"></a><!-- doxytag: member="boost::numeric::ublas::vector::operator=" ref="af778c9aad1d18346fe2ec22642454755" args="(const vector_container&lt; C &gt; &amp;v)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
<div class="memtemplate">
template&lt;class C &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&amp; <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::operator= </td>
          <td>(</td>
          <td class="paramtype">const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__container.html">vector_container</a>&lt; C &gt; &amp;&nbsp;</td>
          <td class="paramname"> <em>v</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>v</em>&nbsp;</td><td>is the source <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> container </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>a reference to a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> (i.e. the destination <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>) </dd></dl>

<p>Reimplemented in <a class="el" href="classboost_1_1numeric_1_1ublas_1_1bounded__vector.html#a4a7502fc64dded94ce5b719da367c2f4">boost::numeric::ublas::bounded_vector&lt; T, N &gt;</a>.</p>

</div>
</div>
<a class="anchor" id="a1724d353e3006619a995342bc6be134e"></a><!-- doxytag: member="boost::numeric::ublas::vector::operator=" ref="a1724d353e3006619a995342bc6be134e" args="(const vector &amp;v)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&amp; <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::operator= </td>
          <td>(</td>
          <td class="paramtype">const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&lt; T, A &gt; &amp;&nbsp;</td>
          <td class="paramname"> <em>v</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>v</em>&nbsp;</td><td>is the source <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>a reference to a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> (i.e. the destination <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>) </dd></dl>

<p>Reimplemented in <a class="el" href="classboost_1_1numeric_1_1ublas_1_1permutation__matrix.html#aa240d3636599dccd87e7c17d62e3c96f">boost::numeric::ublas::permutation_matrix&lt; T, A &gt;</a>.</p>

</div>
</div>
<a class="anchor" id="a10b3c5c3a5042f21a996eeb75c447529"></a><!-- doxytag: member="boost::numeric::ublas::vector::operator[]" ref="a10b3c5c3a5042f21a996eeb75c447529" args="(size_type i)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE reference <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::operator[] </td>
          <td>(</td>
          <td class="paramtype">size_type&nbsp;</td>
          <td class="paramname"> <em>i</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>i</em>&nbsp;</td><td>index of the element </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a0cfc171dac4e78549a96c43062a052c6"></a><!-- doxytag: member="boost::numeric::ublas::vector::operator[]" ref="a0cfc171dac4e78549a96c43062a052c6" args="(size_type i) const " -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE const_reference <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::operator[] </td>
          <td>(</td>
          <td class="paramtype">size_type&nbsp;</td>
          <td class="paramname"> <em>i</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td> const</td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>i</em>&nbsp;</td><td>index of the element </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="afd874b1ba7fe6a5b961cc3b228cd1208"></a><!-- doxytag: member="boost::numeric::ublas::vector::plus_assign" ref="afd874b1ba7fe6a5b961cc3b228cd1208" args="(const vector_expression&lt; AE &gt; &amp;ae)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
<div class="memtemplate">
template&lt;class AE &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&amp; <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::plus_assign </td>
          <td>(</td>
          <td class="paramtype">const <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html">vector_expression</a>&lt; AE &gt; &amp;&nbsp;</td>
          <td class="paramname"> <em>ae</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Template Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>AE</em>&nbsp;</td><td>is the type of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>ae</em>&nbsp;</td><td>is a const reference to the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector__expression.html" title="Base class for Vector Expression models.">vector_expression</a> </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>a reference to the resulting <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> </dd></dl>

</div>
</div>
<a class="anchor" id="a113118def88db3755da6690b6ec903f0"></a><!-- doxytag: member="boost::numeric::ublas::vector::resize" ref="a113118def88db3755da6690b6ec903f0" args="(size_type size, bool preserve=true)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE void <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::resize </td>
          <td>(</td>
          <td class="paramtype">size_type&nbsp;</td>
          <td class="paramname"> <em>size</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">bool&nbsp;</td>
          <td class="paramname"> <em>preserve</em> = <code>true</code></td><td>&nbsp;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>size</em>&nbsp;</td><td>new size of the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> </td></tr>
    <tr><td valign="top"></td><td valign="top"><em>preserve</em>&nbsp;</td><td>if true, keep values </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a44062e23411cf30e80dd25d500cdfe2e"></a><!-- doxytag: member="boost::numeric::ublas::vector::serialize" ref="a44062e23411cf30e80dd25d500cdfe2e" args="(Archive &amp;ar, const unsigned int)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
<div class="memtemplate">
template&lt;class Archive &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">void <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::serialize </td>
          <td>(</td>
          <td class="paramtype">Archive &amp;&nbsp;</td>
          <td class="paramname"> <em>ar</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const unsigned&nbsp;</td>
          <td class="paramname"> <em>int</em></td><td>&nbsp;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Serialize a <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> into and archive as defined in Boost </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>ar</em>&nbsp;</td><td>Archive object. Can be a flat file, an XML file or any other stream </td></tr>
    <tr><td valign="top"></td><td valign="top"><em>file_version</em>&nbsp;</td><td>Optional file version (not yet used) </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="aedce8a2ea66b86b1e3efb21bba7be0c5"></a><!-- doxytag: member="boost::numeric::ublas::vector::swap" ref="aedce8a2ea66b86b1e3efb21bba7be0c5" args="(vector &amp;v)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE void <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">boost::numeric::ublas::vector</a>&lt; T, A &gt;::swap </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&lt; T, A &gt; &amp;&nbsp;</td>
          <td class="paramname"> <em>v</em></td>
          <td>&nbsp;)&nbsp;</td>
          <td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>v</em>&nbsp;</td><td>is the <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> to be swapped with </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<hr/><h2>Friends And Related Function Documentation</h2>
<a class="anchor" id="a7ec2565da7f04f5f8ba42785be772df7"></a><!-- doxytag: member="boost::numeric::ublas::vector::swap" ref="a7ec2565da7f04f5f8ba42785be772df7" args="(vector &amp;v1, vector &amp;v2)" -->
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class T, class A&gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">BOOST_UBLAS_INLINE friend void swap </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&lt; T, A &gt; &amp;&nbsp;</td>
          <td class="paramname"> <em>v1</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype"><a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html">vector</a>&lt; T, A &gt; &amp;&nbsp;</td>
          <td class="paramname"> <em>v2</em></td><td>&nbsp;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td><td><code> [friend]</code></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<dl><dt><b>Parameters:</b></dt><dd>
  <table border="0" cellspacing="2" cellpadding="0">
    <tr><td valign="top"></td><td valign="top"><em>v1</em>&nbsp;</td><td>is the first <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a>. It takes values from v2 </td></tr>
    <tr><td valign="top"></td><td valign="top"><em>v2</em>&nbsp;</td><td>is the second <a class="el" href="classboost_1_1numeric_1_1ublas_1_1vector.html" title="A dense vector of values of type T.">vector</a> It takes values from v1 </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
</div>
<hr size="1"/><address style="text-align: right;"><small>Generated on Sun Jul 4 20:31:07 2010 for ublas by&nbsp;
<a href="http://www.doxygen.org/index.html">
<img class="footer" src="doxygen.png" alt="doxygen"/></a> 1.6.1 </small></address>
</body>
</html>
