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

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

#include <lu.hpp>

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

List of all members.

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 vector_type::size_type size_type
typedef dense_tag storage_category
typedef vector_tag type_category
typedef T value_type
typedef self_type vector_temporary_type
typedef vector< T, A > vector_type

Public Member Functions

BOOST_UBLAS_INLINE permutation_matrix (size_type size)
BOOST_UBLAS_INLINE permutation_matrix (const vector_type &init)
BOOST_UBLAS_INLINE ~permutation_matrix ()
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 container_typeoperator() ()
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 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
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 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 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 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
permutation_matrix
operator= (const permutation_matrix &m)
BOOST_UBLAS_INLINE reference operator[] (size_type i)
 Return a reference to the element $i$.
BOOST_UBLAS_INLINE const_reference operator[] (size_type i) const
 Return a const 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
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 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 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
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 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

Friends

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

Detailed Description

template<class T = std::size_t, class A = unbounded_array<T>>
class boost::numeric::ublas::permutation_matrix< T, A >

Template Parameters:
T
A

Definition at line 32 of file lu.hpp.


Member Typedef Documentation

template<class T = std::size_t, class A = unbounded_array<T>>
typedef vector<T, A> boost::numeric::ublas::permutation_matrix< T, A >::vector_type

Definition at line 35 of file lu.hpp.

template<class T = std::size_t, class A = unbounded_array<T>>
typedef vector_type::size_type boost::numeric::ublas::permutation_matrix< T, A >::size_type

Reimplemented from boost::numeric::ublas::vector< T, A >.

Definition at line 36 of file lu.hpp.

template<class T, class A>
typedef A::difference_type boost::numeric::ublas::vector< T, A >::difference_type [inherited]

Definition at line 41 of file vector.hpp.

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

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 [inherited]

Definition at line 43 of file vector.hpp.

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

Definition at line 44 of file vector.hpp.

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

Definition at line 45 of file vector.hpp.

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

Definition at line 46 of file vector.hpp.

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

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 [inherited]

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 [inherited]

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 [inherited]

Definition at line 50 of file vector.hpp.

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

Definition at line 51 of file vector.hpp.

template<class T, class A>
typedef reverse_iterator_base<const_iterator> boost::numeric::ublas::vector< T, A >::const_reverse_iterator [inherited]

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 [inherited]

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 = std::size_t, class A = unbounded_array<T>>
BOOST_UBLAS_INLINE boost::numeric::ublas::permutation_matrix< T, A >::permutation_matrix ( size_type  size) [inline, explicit]

Definition at line 41 of file lu.hpp.

template<class T = std::size_t, class A = unbounded_array<T>>
BOOST_UBLAS_INLINE boost::numeric::ublas::permutation_matrix< T, A >::permutation_matrix ( const vector_type init) [inline, explicit]

Definition at line 48 of file lu.hpp.

template<class T = std::size_t, class A = unbounded_array<T>>
BOOST_UBLAS_INLINE boost::numeric::ublas::permutation_matrix< T, A >::~permutation_matrix ( ) [inline]

Definition at line 52 of file lu.hpp.


Member Function Documentation

template<class T = std::size_t, class A = unbounded_array<T>>
BOOST_UBLAS_INLINE permutation_matrix& boost::numeric::ublas::permutation_matrix< T, A >::operator= ( const permutation_matrix< T, A > &  m) [inline]

Definition at line 56 of file lu.hpp.

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

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, inherited]

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, inherited]

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, inherited]

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, inherited]

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, inherited]

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, inherited]

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, inherited]

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, inherited]

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, inherited]

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.

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]
template<class T, class A>
BOOST_UBLAS_INLINE const_reference boost::numeric::ublas::vector< T, A >::operator[] ( size_type  i) const [inline, inherited]

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, inherited]

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, inherited]

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, inherited]

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, inherited]

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 >::assign_temporary ( vector< T, A > &  v) [inline, inherited]

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 >::assign ( const vector_expression< AE > &  ae) [inline, inherited]

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, inherited]

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, inherited]

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, inherited]

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, inherited]

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, inherited]

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, inherited]

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, inherited]

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, inherited]

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, inherited]

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, inherited]

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, inherited]

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, inherited]

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 iterator boost::numeric::ublas::vector< T, A >::begin ( ) [inline, inherited]

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 const_iterator boost::numeric::ublas::vector< T, A >::end ( ) const [inline, inherited]

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 >::end ( ) [inline, inherited]

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, inherited]

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 reverse_iterator boost::numeric::ublas::vector< T, A >::rbegin ( ) [inline, inherited]

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 const_reverse_iterator boost::numeric::ublas::vector< T, A >::rend ( ) const [inline, inherited]

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 >::rend ( ) [inline, inherited]

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, inherited]

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.


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, inherited]

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

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

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