Boost.uBlas 1.49
Linear Algebra in C++: matrices, vectors and numeric algorithms

boost::numeric::ublas::vector< T, A > Class Template Reference

A dense vector of values of type T. More...

#include <vector.hpp>

Inheritance diagram for boost::numeric::ublas::vector< T, A >:
Collaboration diagram for boost::numeric::ublas::vector< T, A >:

List of all members.

Classes

class  const_iterator
class  iterator

Public Types

typedef A array_type
typedef vector_reference
< self_type
closure_type
typedef const vector_reference
< const self_type
const_closure_type
typedef const T * const_pointer
typedef type_traits< T >
::const_reference 
const_reference
typedef reverse_iterator_base
< const_iterator
const_reverse_iterator
typedef vector< T, A > container_type
typedef A::difference_type difference_type
typedef vector< T, A > expression_type
typedef T * pointer
typedef T & reference
typedef reverse_iterator_base
< iterator
reverse_iterator
typedef A::size_type size_type
typedef dense_tag storage_category
typedef vector_tag type_category
typedef T value_type
typedef self_type vector_temporary_type

Public Member Functions

BOOST_UBLAS_INLINE vector ()
 Constructor of a vector By default it is empty, i.e. size()==0.
BOOST_UBLAS_INLINE vector (size_type size)
 Constructor of a vector with a predefined size By default, its elements are initialized to 0.
BOOST_UBLAS_INLINE vector (const array_type &data)
 Constructor of a vector by copying from another container This type has the generic name array_typ within the vector definition.
BOOST_UBLAS_INLINE vector (size_type size, const value_type &init)
 Constructor of a vector with a predefined size and a unique initial value.
BOOST_UBLAS_INLINE vector (size_type size, const array_type &data)
 Constructor of a vector by copying from another container This type has the generic name array_typ within the vector definition.
BOOST_UBLAS_INLINE vector (const vector &v)
 Copy-constructor of a vector.
template<class AE >
BOOST_UBLAS_INLINE vector (const vector_expression< AE > &ae)
 Copy-constructor of a vector from a vector_expression Depending on the vector_expression, 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).
template<class AE >
BOOST_UBLAS_INLINE vectorassign (const vector_expression< AE > &ae)
 Assign the result of a vector_expression to the vector Assign the result of a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
BOOST_UBLAS_INLINE vectorassign_temporary (vector &v)
 Assign a full vector (RHS-vector) to the current vector (LHS-vector)
BOOST_UBLAS_INLINE const_iterator begin () const
 return an iterator on the first element of the vector
BOOST_UBLAS_INLINE iterator begin ()
 Return an iterator on the first element of the vector.
BOOST_UBLAS_INLINE void clear ()
 Clear the vector, i.e. set all values to the zero value.
BOOST_UBLAS_INLINE const
array_type
data () const
 Return a const reference to the container. Useful to access data directly for specific type of container.
BOOST_UBLAS_INLINE array_typedata ()
 Return a reference to the container. Useful to speed-up write operations to the data in very specific case.
BOOST_UBLAS_INLINE bool empty () const
 Return true if the vector is empty (size==0)
BOOST_UBLAS_INLINE const_iterator end () const
 return an iterator after the last element of the vector
BOOST_UBLAS_INLINE iterator end ()
 Return an iterator at the end of the vector.
BOOST_UBLAS_INLINE void erase_element (size_type i)
 Set element $i$ to the zero value.
BOOST_UBLAS_INLINE const_iterator find (size_type i) const
 Return a const iterator to the element i.
BOOST_UBLAS_INLINE iterator find (size_type i)
 Return an iterator to the element i.
BOOST_UBLAS_INLINE pointer find_element (size_type i)
 Return a pointer to the element $i$.
BOOST_UBLAS_INLINE const_pointer find_element (size_type i) const
 Return a const pointer to the element $i$.
BOOST_UBLAS_INLINE reference insert_element (size_type i, const_reference t)
 Set element $i$ to the value t.
BOOST_UBLAS_INLINE size_type max_size () const
 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 vector.
template<class AE >
BOOST_UBLAS_INLINE vectorminus_assign (const vector_expression< AE > &ae)
 Assign the difference of the vector and a vector_expression to the vector Assign the difference of the vector and a vector_expression to the vector. 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 vector.
BOOST_UBLAS_INLINE reference operator() (size_type i)
 Return a reference to the element $i$ Return a reference to the element $i$. With some compilers, this notation will be faster than [i].
BOOST_UBLAS_INLINE const_reference operator() (size_type i) const
 Return a const reference to the element $i$ Return a const reference to the element $i$. With some compilers, this notation will be faster than [i].
BOOST_UBLAS_INLINE container_typeoperator() ()
BOOST_UBLAS_INLINE const
container_type
operator() () const
template<class AT >
BOOST_UBLAS_INLINE vectoroperator*= (const AT &at)
 Assign the product of the vector and a scalar to the vector Assign the product of the vector and a scalar to the vector. 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 vector.
template<class AE >
BOOST_UBLAS_INLINE vectoroperator+= (const vector_expression< AE > &ae)
 Assign the sum of the vector and a vector_expression to the vector Assign the sum of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. A temporary is created for the computations.
template<class C >
BOOST_UBLAS_INLINE vectoroperator+= (const vector_container< C > &v)
 Assign the sum of the vector and a vector_expression to the vector Assign the sum of the vector and a vector_expression to the vector. 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 vector.
template<class C >
BOOST_UBLAS_INLINE vectoroperator-= (const vector_container< C > &v)
 Assign the difference of the vector and a vector_expression to the vector Assign the difference of the vector and a vector_expression to the vector. 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 vector.
template<class AE >
BOOST_UBLAS_INLINE vectoroperator-= (const vector_expression< AE > &ae)
 Assign the difference of the vector and a vector_expression to the vector Assign the difference of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. A temporary is created for the computations.
template<class AT >
BOOST_UBLAS_INLINE vectoroperator/= (const AT &at)
 Assign the division of the vector by a scalar to the vector Assign the division of the vector by a scalar to the vector. 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 vector.
BOOST_UBLAS_INLINE vectoroperator= (const vector &v)
 Assign a full vector (RHS-vector) to the current vector (LHS-vector)
template<class C >
BOOST_UBLAS_INLINE vectoroperator= (const vector_container< C > &v)
 Assign a full vector (RHS-vector) to the current vector (LHS-vector) Assign a full vector (RHS-vector) to the current vector (LHS-vector). This method does not create any temporary.
template<class AE >
BOOST_UBLAS_INLINE vectoroperator= (const vector_expression< AE > &ae)
 Assign the result of a vector_expression to the vector Assign the result of a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 Return a const reference to the element $i$.
BOOST_UBLAS_INLINE reference operator[] (size_type i)
 Return a reference to the element $i$.
template<class AE >
BOOST_UBLAS_INLINE vectorplus_assign (const vector_expression< AE > &ae)
 Assign the sum of the vector and a vector_expression to the vector Assign the sum of the vector and a vector_expression to the vector. 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 vector.
BOOST_UBLAS_INLINE reverse_iterator rbegin ()
 Return a const reverse iterator before the first element of the reversed vector (i.e. end() of normal vector)
BOOST_UBLAS_INLINE
const_reverse_iterator 
rbegin () const
 Return a const reverse iterator before the first element of the reversed vector (i.e. end() of normal vector)
BOOST_UBLAS_INLINE
const_reverse_iterator 
rend () const
 Return a const reverse iterator on the end of the reverse vector (i.e. first element of the normal vector)
BOOST_UBLAS_INLINE reverse_iterator rend ()
 Return a const reverse iterator on the end of the reverse vector (i.e. first element of the normal vector)
BOOST_UBLAS_INLINE void resize (size_type size, bool preserve=true)
 Resize the vector Resize the vector to a new size. If preserve 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 unbounded_array, 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.
template<class Archive >
void serialize (Archive &ar, const unsigned int)
BOOST_UBLAS_INLINE size_type size () const
 Return the size of the vector.
BOOST_UBLAS_INLINE void swap (vector &v)
 Swap the content of the vector with another vector.

Static Public Attributes

static const unsigned complexity

Private Types

typedef A::const_iterator const_subiterator_type
typedef vector< T, A > self_type
typedef A::iterator subiterator_type

Private Attributes

array_type data_

Friends

BOOST_UBLAS_INLINE friend void swap (vector &v1, vector &v2)
 Swap the content of two vectors.

Detailed Description

template<class T, class A>
class boost::numeric::ublas::vector< T, A >

A dense vector of values of type T.

For a $n$-dimensional vector $v$ and $0\leq i < n$ every element $v_i$ is mapped to the $i$-th element of the container. A storage type A can be specified which defaults to unbounded_array. Elements are constructed by A, which need not initialise their value.

Template Parameters:
Ttype of the objects stored in the vector (like int, double, complex,...)
AThe type of the storage array of the vector. Default is unbounded_array<T>. <bounded_array<T> and std::vector<T> can also be used

Definition at line 31 of file vector.hpp.


Member Typedef Documentation

template<class T, class A>
typedef vector<T, A> boost::numeric::ublas::vector< T, A >::self_type [private]

Definition at line 34 of file vector.hpp.

template<class T, class A>
typedef A::size_type boost::numeric::ublas::vector< T, A >::size_type
template<class T, class A>
typedef A::difference_type boost::numeric::ublas::vector< T, A >::difference_type

Definition at line 41 of file vector.hpp.

template<class T, class A>
typedef T boost::numeric::ublas::vector< T, A >::value_type

Definition at line 42 of file vector.hpp.

template<class T, class A>
typedef type_traits<T>::const_reference boost::numeric::ublas::vector< T, A >::const_reference

Definition at line 43 of file vector.hpp.

template<class T, class A>
typedef T& boost::numeric::ublas::vector< T, A >::reference

Definition at line 44 of file vector.hpp.

template<class T, class A>
typedef T* boost::numeric::ublas::vector< T, A >::pointer

Definition at line 45 of file vector.hpp.

template<class T, class A>
typedef const T* boost::numeric::ublas::vector< T, A >::const_pointer

Definition at line 46 of file vector.hpp.

template<class T, class A>
typedef A boost::numeric::ublas::vector< T, A >::array_type

Definition at line 47 of file vector.hpp.

template<class T, class A>
typedef const vector_reference<const self_type> boost::numeric::ublas::vector< T, A >::const_closure_type

Definition at line 48 of file vector.hpp.

template<class T, class A>
typedef vector_reference<self_type> boost::numeric::ublas::vector< T, A >::closure_type

Definition at line 49 of file vector.hpp.

template<class T, class A>
typedef self_type boost::numeric::ublas::vector< T, A >::vector_temporary_type

Definition at line 50 of file vector.hpp.

template<class T, class A>
typedef dense_tag boost::numeric::ublas::vector< T, A >::storage_category

Definition at line 51 of file vector.hpp.

template<class T, class A>
typedef A::const_iterator boost::numeric::ublas::vector< T, A >::const_subiterator_type [private]

Definition at line 459 of file vector.hpp.

template<class T, class A>
typedef A::iterator boost::numeric::ublas::vector< T, A >::subiterator_type [private]

Definition at line 460 of file vector.hpp.

Definition at line 743 of file vector.hpp.

template<class T, class A>
typedef reverse_iterator_base<iterator> boost::numeric::ublas::vector< T, A >::reverse_iterator

Definition at line 744 of file vector.hpp.

typedef vector< T, A > boost::numeric::ublas::vector_container< vector< T, A > >::container_type [inherited]

Definition at line 281 of file expression_types.hpp.


Constructor & Destructor Documentation

template<class T, class A>
BOOST_UBLAS_INLINE boost::numeric::ublas::vector< T, A >::vector ( ) [inline]

Constructor of a vector By default it is empty, i.e. size()==0.

Definition at line 58 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE boost::numeric::ublas::vector< T, A >::vector ( size_type  size) [inline, explicit]

Constructor of a vector with a predefined size By default, its elements are initialized to 0.

Parameters:
sizeinitial size of the vector

Definition at line 66 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE boost::numeric::ublas::vector< T, A >::vector ( size_type  size,
const array_type data 
) [inline]

Constructor of a vector by copying from another container This type has the generic name array_typ within the vector definition.

Parameters:
sizeinitial size of the vector
datacontainer of type A

Definition at line 77 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE boost::numeric::ublas::vector< T, A >::vector ( const array_type data) [inline]

Constructor of a vector by copying from another container This type has the generic name array_typ within the vector definition.

Parameters:
datacontainer of type A

Definition at line 85 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE boost::numeric::ublas::vector< T, A >::vector ( size_type  size,
const value_type init 
) [inline]

Constructor of a vector with a predefined size and a unique initial value.

Parameters:
sizeof the vector
initvalue to assign to each element of the vector

Definition at line 93 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE boost::numeric::ublas::vector< T, A >::vector ( const vector< T, A > &  v) [inline]

Copy-constructor of a vector.

Parameters:
vis the vector to be duplicated

Definition at line 100 of file vector.hpp.

template<class T, class A>
template<class AE >
BOOST_UBLAS_INLINE boost::numeric::ublas::vector< T, A >::vector ( const vector_expression< AE > &  ae) [inline]

Copy-constructor of a vector from a vector_expression Depending on the vector_expression, 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).

Parameters:
aethe vector_expression which values will be duplicated into the vector

Definition at line 110 of file vector.hpp.


Member Function Documentation

template<class T, class A>
BOOST_UBLAS_INLINE size_type boost::numeric::ublas::vector< T, A >::max_size ( ) const [inline]

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 vector.

Definition at line 123 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE bool boost::numeric::ublas::vector< T, A >::empty ( ) const [inline]

Return true if the vector is empty (size==0)

Returns:
true if empty, false otherwise

Definition at line 130 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE size_type boost::numeric::ublas::vector< T, A >::size ( ) const [inline]

Return the size of the vector.

Definition at line 140 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE const array_type& boost::numeric::ublas::vector< T, A >::data ( ) const [inline]

Return a const reference to the container. Useful to access data directly for specific type of container.

Definition at line 150 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE array_type& boost::numeric::ublas::vector< T, A >::data ( ) [inline]

Return a reference to the container. Useful to speed-up write operations to the data in very specific case.

Definition at line 156 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE void boost::numeric::ublas::vector< T, A >::resize ( size_type  size,
bool  preserve = true 
) [inline]

Resize the vector Resize the vector to a new size. If preserve 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 unbounded_array, 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.

Parameters:
sizenew size of the vector
preserveif true, keep values

Definition at line 169 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE pointer boost::numeric::ublas::vector< T, A >::find_element ( size_type  i) [inline]

Return a pointer to the element $i$.

Parameters:
iindex of the element

Definition at line 184 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE const_pointer boost::numeric::ublas::vector< T, A >::find_element ( size_type  i) const [inline]

Return a const pointer to the element $i$.

Parameters:
iindex of the element

Definition at line 192 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE const_reference boost::numeric::ublas::vector< T, A >::operator() ( size_type  i) const [inline]

Return a const reference to the element $i$ Return a const reference to the element $i$. With some compilers, this notation will be faster than [i].

Parameters:
iindex of the element

Definition at line 204 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE reference boost::numeric::ublas::vector< T, A >::operator() ( size_type  i) [inline]

Return a reference to the element $i$ Return a reference to the element $i$. With some compilers, this notation will be faster than [i].

Parameters:
iindex of the element

Definition at line 212 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE const_reference boost::numeric::ublas::vector< T, A >::operator[] ( size_type  i) const [inline]

Return a const reference to the element $i$.

Parameters:
iindex of the element

Definition at line 219 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE reference boost::numeric::ublas::vector< T, A >::operator[] ( size_type  i) [inline]

Return a reference to the element $i$.

Parameters:
iindex of the element

Definition at line 226 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE reference boost::numeric::ublas::vector< T, A >::insert_element ( size_type  i,
const_reference  t 
) [inline]

Set element $i$ to the value t.

Parameters:
iindex of the element
treference to the value to be set

Definition at line 239 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE void boost::numeric::ublas::vector< T, A >::erase_element ( size_type  i) [inline]

Set element $i$ to the zero value.

Parameters:
iindex of the element

Definition at line 246 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE void boost::numeric::ublas::vector< T, A >::clear ( ) [inline]

Clear the vector, i.e. set all values to the zero value.

Definition at line 256 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE vector& boost::numeric::ublas::vector< T, A >::operator= ( const vector< T, A > &  v) [inline]

Assign a full vector (RHS-vector) to the current vector (LHS-vector)

Parameters:
vis the source vector
Returns:
a reference to a vector (i.e. the destination vector)

Definition at line 277 of file vector.hpp.

template<class T, class A>
template<class C >
BOOST_UBLAS_INLINE vector& boost::numeric::ublas::vector< T, A >::operator= ( const vector_container< C > &  v) [inline]

Assign a full vector (RHS-vector) to the current vector (LHS-vector) Assign a full vector (RHS-vector) to the current vector (LHS-vector). This method does not create any temporary.

Parameters:
vis the source vector container
Returns:
a reference to a vector (i.e. the destination vector)

Reimplemented in boost::numeric::ublas::bounded_vector< T, N >.

Definition at line 289 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE vector& boost::numeric::ublas::vector< T, A >::assign_temporary ( vector< T, A > &  v) [inline]

Assign a full vector (RHS-vector) to the current vector (LHS-vector)

Parameters:
vis the source vector
Returns:
a reference to a vector (i.e. the destination vector)

Definition at line 299 of file vector.hpp.

template<class T, class A>
template<class AE >
BOOST_UBLAS_INLINE vector& boost::numeric::ublas::vector< T, A >::operator= ( const vector_expression< AE > &  ae) [inline]

Assign the result of a vector_expression to the vector Assign the result of a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.

Template Parameters:
AEis the type of the vector_expression
Parameters:
aeis a const reference to the vector_expression
Returns:
a reference to the resulting vector

Reimplemented in boost::numeric::ublas::bounded_vector< T, N >.

Definition at line 311 of file vector.hpp.

template<class T, class A>
template<class AE >
BOOST_UBLAS_INLINE vector& boost::numeric::ublas::vector< T, A >::assign ( const vector_expression< AE > &  ae) [inline]

Assign the result of a vector_expression to the vector Assign the result of a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.

Template Parameters:
AEis the type of the vector_expression
Parameters:
aeis a const reference to the vector_expression
Returns:
a reference to the resulting vector

Definition at line 323 of file vector.hpp.

template<class T, class A>
template<class AE >
BOOST_UBLAS_INLINE vector& boost::numeric::ublas::vector< T, A >::operator+= ( const vector_expression< AE > &  ae) [inline]

Assign the sum of the vector and a vector_expression to the vector Assign the sum of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. A temporary is created for the computations.

Template Parameters:
AEis the type of the vector_expression
Parameters:
aeis a const reference to the vector_expression
Returns:
a reference to the resulting vector

Definition at line 340 of file vector.hpp.

template<class T, class A>
template<class C >
BOOST_UBLAS_INLINE vector& boost::numeric::ublas::vector< T, A >::operator+= ( const vector_container< C > &  v) [inline]

Assign the sum of the vector and a vector_expression to the vector Assign the sum of the vector and a vector_expression to the vector. 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 vector.

Template Parameters:
AEis the type of the vector_expression
Parameters:
aeis a const reference to the vector_expression
Returns:
a reference to the resulting vector

Definition at line 353 of file vector.hpp.

template<class T, class A>
template<class AE >
BOOST_UBLAS_INLINE vector& boost::numeric::ublas::vector< T, A >::plus_assign ( const vector_expression< AE > &  ae) [inline]

Assign the sum of the vector and a vector_expression to the vector Assign the sum of the vector and a vector_expression to the vector. 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 vector.

Template Parameters:
AEis the type of the vector_expression
Parameters:
aeis a const reference to the vector_expression
Returns:
a reference to the resulting vector

Definition at line 366 of file vector.hpp.

template<class T, class A>
template<class AE >
BOOST_UBLAS_INLINE vector& boost::numeric::ublas::vector< T, A >::operator-= ( const vector_expression< AE > &  ae) [inline]

Assign the difference of the vector and a vector_expression to the vector Assign the difference of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. A temporary is created for the computations.

Template Parameters:
AEis the type of the vector_expression
Parameters:
aeis a const reference to the vector_expression

Definition at line 378 of file vector.hpp.

template<class T, class A>
template<class C >
BOOST_UBLAS_INLINE vector& boost::numeric::ublas::vector< T, A >::operator-= ( const vector_container< C > &  v) [inline]

Assign the difference of the vector and a vector_expression to the vector Assign the difference of the vector and a vector_expression to the vector. 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 vector.

Template Parameters:
AEis the type of the vector_expression
Parameters:
aeis a const reference to the vector_expression
Returns:
a reference to the resulting vector

Definition at line 391 of file vector.hpp.

template<class T, class A>
template<class AE >
BOOST_UBLAS_INLINE vector& boost::numeric::ublas::vector< T, A >::minus_assign ( const vector_expression< AE > &  ae) [inline]

Assign the difference of the vector and a vector_expression to the vector Assign the difference of the vector and a vector_expression to the vector. 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 vector.

Template Parameters:
AEis the type of the vector_expression
Parameters:
aeis a const reference to the vector_expression
Returns:
a reference to the resulting vector

Definition at line 404 of file vector.hpp.

template<class T, class A>
template<class AT >
BOOST_UBLAS_INLINE vector& boost::numeric::ublas::vector< T, A >::operator*= ( const AT &  at) [inline]

Assign the product of the vector and a scalar to the vector Assign the product of the vector and a scalar to the vector. 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 vector.

Template Parameters:
AEis the type of the vector_expression
Parameters:
atis a const reference to the scalar
Returns:
a reference to the resulting vector

Definition at line 417 of file vector.hpp.

template<class T, class A>
template<class AT >
BOOST_UBLAS_INLINE vector& boost::numeric::ublas::vector< T, A >::operator/= ( const AT &  at) [inline]

Assign the division of the vector by a scalar to the vector Assign the division of the vector by a scalar to the vector. 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 vector.

Template Parameters:
AEis the type of the vector_expression
Parameters:
atis a const reference to the scalar
Returns:
a reference to the resulting vector

Definition at line 430 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE void boost::numeric::ublas::vector< T, A >::swap ( vector< T, A > &  v) [inline]

Swap the content of the vector with another vector.

Parameters:
vis the vector to be swapped with

Definition at line 442 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE const_iterator boost::numeric::ublas::vector< T, A >::find ( size_type  i) const [inline]

Return a const iterator to the element i.

Parameters:
iindex of the element

Definition at line 478 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE iterator boost::numeric::ublas::vector< T, A >::find ( size_type  i) [inline]

Return an iterator to the element i.

Parameters:
iindex of the element

Definition at line 489 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE const_iterator boost::numeric::ublas::vector< T, A >::begin ( ) const [inline]

return an iterator on the first element of the vector

Definition at line 628 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE const_iterator boost::numeric::ublas::vector< T, A >::end ( ) const [inline]

return an iterator after the last element of the vector

Definition at line 634 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE iterator boost::numeric::ublas::vector< T, A >::begin ( ) [inline]

Return an iterator on the first element of the vector.

Definition at line 732 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE iterator boost::numeric::ublas::vector< T, A >::end ( ) [inline]

Return an iterator at the end of the vector.

Definition at line 738 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE const_reverse_iterator boost::numeric::ublas::vector< T, A >::rbegin ( ) const [inline]

Return a const reverse iterator before the first element of the reversed vector (i.e. end() of normal vector)

Definition at line 748 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE const_reverse_iterator boost::numeric::ublas::vector< T, A >::rend ( ) const [inline]

Return a const reverse iterator on the end of the reverse vector (i.e. first element of the normal vector)

Definition at line 754 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE reverse_iterator boost::numeric::ublas::vector< T, A >::rbegin ( ) [inline]

Return a const reverse iterator before the first element of the reversed vector (i.e. end() of normal vector)

Definition at line 760 of file vector.hpp.

template<class T, class A>
BOOST_UBLAS_INLINE reverse_iterator boost::numeric::ublas::vector< T, A >::rend ( ) [inline]

Return a const reverse iterator on the end of the reverse vector (i.e. first element of the normal vector)

Definition at line 766 of file vector.hpp.

template<class T, class A>
template<class Archive >
void boost::numeric::ublas::vector< T, A >::serialize ( Archive &  ar,
const unsigned  int 
) [inline]

Serialize a vector into and archive as defined in Boost

Parameters:
arArchive object. Can be a flat file, an XML file or any other stream
file_versionOptional file version (not yet used)

Definition at line 778 of file vector.hpp.

BOOST_UBLAS_INLINE const container_type& boost::numeric::ublas::vector_container< vector< T, A > >::operator() ( ) const [inline, inherited]
BOOST_UBLAS_INLINE container_type& boost::numeric::ublas::vector_container< vector< T, A > >::operator() ( ) [inline, inherited]

Friends And Related Function Documentation

template<class T, class A>
BOOST_UBLAS_INLINE friend void swap ( vector< T, A > &  v1,
vector< T, A > &  v2 
) [friend]

Swap the content of two vectors.

Parameters:
v1is the first vector. It takes values from v2
v2is the second vector It takes values from v1

Definition at line 452 of file vector.hpp.


Member Data Documentation

template<class T, class A>
array_type boost::numeric::ublas::vector< T, A >::data_ [private]

Definition at line 783 of file vector.hpp.

const unsigned boost::numeric::ublas::vector_container< vector< T, A > >::complexity [static, inherited]

The documentation for this class was generated from the following file: