Dune::block_vector_unmanaged< B, A > Class Template Reference

An unmanaged vector of blocks. More...

#include <dune/istl/bvector.hh>

Inheritance diagram for Dune::block_vector_unmanaged< B, A >:
Inheritance graph

List of all members.

Public Types

typedef B::field_type field_type
 export the type representing the field
typedef B block_type
 export the type representing the components
typedef A allocator_type
 export the allocator type
typedef A::size_type size_type
 The size type for the index access.
typedef base_array_unmanaged
< B, A >::iterator 
Iterator
 make iterators available as types
typedef base_array_unmanaged
< B, A >::const_iterator 
ConstIterator
 make iterators available as types
typedef B value_type
 for STL compatibility
typedef B member_type
 export the type representing the components
typedef RealIterator< B > iterator
 iterator type for sequential access
typedef RealIterator< const B > const_iterator
 iterator class for sequential access

Public Member Functions

block_vector_unmanagedoperator= (const field_type &k)
 Assignment from a scalar.
block_vector_unmanagedoperator+= (const block_vector_unmanaged &y)
 vector space addition
block_vector_unmanagedoperator-= (const block_vector_unmanaged &y)
 vector space subtraction
block_vector_unmanagedoperator*= (const field_type &k)
 vector space multiplication with scalar
block_vector_unmanagedoperator/= (const field_type &k)
 vector space division by scalar
block_vector_unmanagedaxpy (const field_type &a, const block_vector_unmanaged &y)
 vector space axpy operation
field_type operator* (const block_vector_unmanaged &y) const
 scalar product
double one_norm () const
 one norm (sum over absolute values of entries)
double one_norm_real () const
 simplified one norm (uses Manhattan norm for complex values)
double two_norm () const
 two norm sqrt(sum over squared values of entries)
double two_norm2 () const
 sqare of two norm (sum over squared values of entries), need for block recursion
double infinity_norm () const
 infinity norm (maximum of absolute values of entries)
double infinity_norm_real () const
 simplified infinity norm (uses Manhattan norm for complex values)
size_type N () const
 number of blocks in the vector (are of size 1 here)
size_type dim () const
 dimension of the vector space
B & operator[] (size_type i)
 random access to blocks
const B & operator[] (size_type i) const
 same for read only access
iterator begin ()
 begin iterator
const_iterator begin () const
 begin const_iterator
iterator end ()
 end iterator
const_iterator end () const
 end const_iterator
iterator rbegin ()
const_iterator rbegin () const
iterator beforeEnd ()
const_iterator beforeEnd () const
iterator rend ()
const_iterator rend () const
iterator beforeBegin ()
const_iterator beforeBegin () const
iterator find (size_type i)
 random access returning iterator (end if not contained)
const_iterator find (size_type i) const
 random access returning iterator (end if not contained)
size_type size () const
 number of blocks in the array (are of size 1 here)

Protected Member Functions

 block_vector_unmanaged ()
 make constructor protected, so only derived classes can be instantiated

Protected Attributes

size_type n
B * p

Detailed Description

template<class B, class A = std::allocator<B>>
class Dune::block_vector_unmanaged< B, A >

An unmanaged vector of blocks.

block_vector_unmanaged extends the base_array_unmanaged by vector operations such as addition and scalar multiplication. No memory management is added.

Error checking: no error checking is provided normally. Setting the compile time switch DUNE_ISTL_WITH_CHECKING enables error checking.


Member Typedef Documentation

template<class B, class A = std::allocator<B>>
typedef B Dune::block_vector_unmanaged< B, A >::block_type
template<class B, class A = std::allocator<B>>
typedef RealIterator<const B> Dune::base_array_unmanaged< B, A >::const_iterator [inherited]

iterator class for sequential access

Reimplemented in Dune::base_array_window< B, A >, and Dune::base_array< B, A >.

template<class B, class A = std::allocator<B>>
typedef base_array_unmanaged<B,A>::const_iterator Dune::block_vector_unmanaged< B, A >::ConstIterator
template<class B, class A = std::allocator<B>>
typedef B::field_type Dune::block_vector_unmanaged< B, A >::field_type
template<class B, class A = std::allocator<B>>
typedef RealIterator<B> Dune::base_array_unmanaged< B, A >::iterator [inherited]

iterator type for sequential access

Reimplemented in Dune::base_array_window< B, A >, and Dune::base_array< B, A >.

template<class B, class A = std::allocator<B>>
typedef base_array_unmanaged<B,A>::iterator Dune::block_vector_unmanaged< B, A >::Iterator
template<class B, class A = std::allocator<B>>
typedef B Dune::base_array_unmanaged< B, A >::member_type [inherited]

export the type representing the components

Reimplemented in Dune::base_array_window< B, A >, and Dune::base_array< B, A >.

template<class B, class A = std::allocator<B>>
typedef A::size_type Dune::block_vector_unmanaged< B, A >::size_type
template<class B, class A = std::allocator<B>>
typedef B Dune::block_vector_unmanaged< B, A >::value_type

for STL compatibility


Constructor & Destructor Documentation

template<class B, class A = std::allocator<B>>
Dune::block_vector_unmanaged< B, A >::block_vector_unmanaged (  )  [inline, protected]

make constructor protected, so only derived classes can be instantiated


Member Function Documentation

template<class B, class A = std::allocator<B>>
block_vector_unmanaged& Dune::block_vector_unmanaged< B, A >::axpy ( const field_type a,
const block_vector_unmanaged< B, A > &  y 
) [inline]

vector space axpy operation

Referenced by Dune::block_vector_unmanaged< T, A >::axpy().

template<class B, class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::beforeBegin (  )  [inline, inherited]
Returns:
an iterator that is positioned before the first entry of the vector.

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

Referenced by Dune::base_array_unmanaged< T, A >::rend().

template<class B, class A = std::allocator<B>>
const_iterator Dune::base_array_unmanaged< B, A >::beforeBegin (  )  const [inline, inherited]
Returns:
an iterator that is positioned before the first entry of the vector.
template<class B, class A = std::allocator<B>>
const_iterator Dune::base_array_unmanaged< B, A >::beforeEnd (  )  const [inline, inherited]
Returns:
an iterator that is positioned before the end iterator of the vector. i.e. at the last element.

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::beforeEnd (  )  [inline, inherited]
Returns:
an iterator that is positioned before the end iterator of the vector, i.e. at the last entry.

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

Referenced by Dune::base_array_unmanaged< T, A >::rbegin().

template<class B, class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::begin (  )  [inline, inherited]

begin iterator

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

Referenced by test_basearray(), and test_IO().

template<class B, class A = std::allocator<B>>
const_iterator Dune::base_array_unmanaged< B, A >::begin (  )  const [inline, inherited]

begin const_iterator

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
size_type Dune::block_vector_unmanaged< B, A >::dim (  )  const [inline]

dimension of the vector space

template<class B, class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::end (  )  [inline, inherited]

end iterator

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

Referenced by test_basearray(), and test_IO().

template<class B, class A = std::allocator<B>>
const_iterator Dune::base_array_unmanaged< B, A >::end (  )  const [inline, inherited]

end const_iterator

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
const_iterator Dune::base_array_unmanaged< B, A >::find ( size_type  i  )  const [inline, inherited]

random access returning iterator (end if not contained)

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::find ( size_type  i  )  [inline, inherited]

random access returning iterator (end if not contained)

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
double Dune::block_vector_unmanaged< B, A >::infinity_norm (  )  const [inline]

infinity norm (maximum of absolute values of entries)

Referenced by Dune::block_vector_unmanaged< T, A >::infinity_norm().

template<class B, class A = std::allocator<B>>
double Dune::block_vector_unmanaged< B, A >::infinity_norm_real (  )  const [inline]

simplified infinity norm (uses Manhattan norm for complex values)

Referenced by Dune::block_vector_unmanaged< T, A >::infinity_norm_real().

template<class B, class A = std::allocator<B>>
double Dune::block_vector_unmanaged< B, A >::one_norm (  )  const [inline]

one norm (sum over absolute values of entries)

template<class B, class A = std::allocator<B>>
double Dune::block_vector_unmanaged< B, A >::one_norm_real (  )  const [inline]

simplified one norm (uses Manhattan norm for complex values)

template<class B, class A = std::allocator<B>>
field_type Dune::block_vector_unmanaged< B, A >::operator* ( const block_vector_unmanaged< B, A > &  y  )  const [inline]

scalar product

template<class B, class A = std::allocator<B>>
block_vector_unmanaged& Dune::block_vector_unmanaged< B, A >::operator*= ( const field_type k  )  [inline]

vector space multiplication with scalar

template<class B, class A = std::allocator<B>>
block_vector_unmanaged& Dune::block_vector_unmanaged< B, A >::operator+= ( const block_vector_unmanaged< B, A > &  y  )  [inline]

vector space addition

template<class B, class A = std::allocator<B>>
block_vector_unmanaged& Dune::block_vector_unmanaged< B, A >::operator-= ( const block_vector_unmanaged< B, A > &  y  )  [inline]

vector space subtraction

template<class B, class A = std::allocator<B>>
block_vector_unmanaged& Dune::block_vector_unmanaged< B, A >::operator/= ( const field_type k  )  [inline]

vector space division by scalar

template<class B, class A = std::allocator<B>>
block_vector_unmanaged& Dune::block_vector_unmanaged< B, A >::operator= ( const field_type k  )  [inline]
template<class B, class A = std::allocator<B>>
const B& Dune::base_array_unmanaged< B, A >::operator[] ( size_type  i  )  const [inline, inherited]

same for read only access

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
B& Dune::base_array_unmanaged< B, A >::operator[] ( size_type  i  )  [inline, inherited]

random access to blocks

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::rbegin (  )  [inline, inherited]
Deprecated:
This method was renamed to make it distinct from the STL version which returns a reverse iterator. Use the new method beforeEnd instead.
Deprecated:

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
const_iterator Dune::base_array_unmanaged< B, A >::rbegin (  )  const [inline, inherited]
Deprecated:
This method was renamed to make it distinct from the STL version which returns a reverse iterator. Use the new method beforeEnd instead.
Deprecated:

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
const_iterator Dune::base_array_unmanaged< B, A >::rend (  )  const [inline, inherited]
Deprecated:
This method was renamed to make it distinct from the STL version which returns a reverse iterator. Use the new method beforeBegin instead.
Deprecated:

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::rend (  )  [inline, inherited]
Deprecated:
This method was renamed to make it distinct from the STL version which returns a reverse iterator. Use the new method beforeBegin instead.
Deprecated:

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
size_type Dune::base_array_unmanaged< B, A >::size (  )  const [inline, inherited]

number of blocks in the array (are of size 1 here)

Referenced by Dune::Matrix< T, A >::coldim().

template<class B, class A = std::allocator<B>>
double Dune::block_vector_unmanaged< B, A >::two_norm (  )  const [inline]

two norm sqrt(sum over squared values of entries)

Referenced by test_Iter().

template<class B, class A = std::allocator<B>>
double Dune::block_vector_unmanaged< B, A >::two_norm2 (  )  const [inline]

sqare of two norm (sum over squared values of entries), need for block recursion


Member Data Documentation

template<class B, class A = std::allocator<B>>
size_type Dune::base_array_unmanaged< B, A >::n [protected, inherited]

Referenced by Dune::base_array_window< B, A >::advance(), Dune::block_vector_unmanaged< T, A >::axpy(), Dune::base_array< B, A >::base_array(), Dune::base_array_unmanaged< T, A >::beforeEnd(), Dune::BlockVector< FieldVector< T, n >, A >::BlockVector(), Dune::BlockVectorWindow< B, A >::BlockVectorWindow(), Dune::block_vector_unmanaged< T, A >::dim(), Dune::base_array_unmanaged< T, A >::end(), Dune::base_array_unmanaged< T, A >::find(), Dune::BlockVectorWindow< B, A >::getsize(), Dune::block_vector_unmanaged< T, A >::infinity_norm(), Dune::block_vector_unmanaged< T, A >::infinity_norm_real(), Dune::base_array_window< B, A >::move(), Dune::block_vector_unmanaged< T, A >::N(), Dune::block_vector_unmanaged< T, A >::one_norm(), Dune::block_vector_unmanaged< T, A >::one_norm_real(), Dune::block_vector_unmanaged< T, A >::operator*(), Dune::block_vector_unmanaged< T, A >::operator*=(), Dune::VariableBlockVector< B, A >::CreateIterator::operator++(), Dune::block_vector_unmanaged< T, A >::operator+=(), Dune::block_vector_unmanaged< T, A >::operator-=(), Dune::block_vector_unmanaged< T, A >::operator/=(), Dune::VariableBlockVector< T, A >::operator=(), Dune::BlockVectorWindow< B, A >::operator=(), Dune::BlockVector< FieldVector< T, n >, A >::operator=(), Dune::block_vector_unmanaged< T, A >::operator=(), Dune::base_array< B, A >::operator=(), Dune::base_array_unmanaged< T, A >::operator[](), Dune::VariableBlockVector< T, A >::resize(), Dune::BlockVector< FieldVector< T, n >, A >::resize(), Dune::base_array< B, A >::resize(), Dune::BlockVectorWindow< B, A >::set(), Dune::base_array_window< B, A >::set(), Dune::BlockVectorWindow< B, A >::setsize(), Dune::base_array_unmanaged< T, A >::size(), Dune::block_vector_unmanaged< T, A >::two_norm(), Dune::block_vector_unmanaged< T, A >::two_norm2(), Dune::VariableBlockVector< T, A >::VariableBlockVector(), Dune::base_array< B, A >::~base_array(), and Dune::VariableBlockVector< T, A >::~VariableBlockVector().


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

Generated on Fri Apr 29 2011 with Doxygen (ver 1.7.1) [doxygen-log,error-log].