dune-istl  2.2.0
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
Dune::compressed_block_vector_unmanaged< B, A > Class Template Reference

#include <dune/istl/bvector.hh>

Inheritance diagram for Dune::compressed_block_vector_unmanaged< B, A >:
Dune::compressed_base_array_unmanaged< B, A > Dune::CompressedBlockVectorWindow< B, A >

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
compressed_base_array_unmanaged
< B, A >::iterator 
Iterator
 make iterators available as types
typedef
compressed_base_array_unmanaged
< B, A >::const_iterator 
ConstIterator
 make iterators available as types
typedef A::size_type size_type
 The type for the index access.
typedef B member_type
 export the type representing the components
typedef RealIterator< B > iterator
 The iterator type.
typedef RealIterator< const B > const_iterator
 const_iterator class for sequential access

Public Member Functions

compressed_block_vector_unmanagedoperator= (const field_type &k)
template<class V >
compressed_block_vector_unmanagedoperator+= (const V &y)
 vector space addition
template<class V >
compressed_block_vector_unmanagedoperator-= (const V &y)
 vector space subtraction
template<class V >
compressed_block_vector_unmanagedaxpy (const field_type &a, const V &y)
 vector space axpy operation
compressed_block_vector_unmanagedoperator*= (const field_type &k)
 vector space multiplication with scalar
compressed_block_vector_unmanagedoperator/= (const field_type &k)
 vector space division by scalar
field_type operator* (const compressed_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, assumes ascending ordering
const B & operator[] (size_type i) const
 same for read only access, assumes ascending ordering
iterator begin ()
 begin iterator
const_iterator begin () const
 begin const_iterator
iterator end ()
 end iterator
const_iterator end () const
 end const_iterator
iterator beforeEnd ()
const_iterator beforeEnd () 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

 compressed_block_vector_unmanaged ()
 make constructor protected, so only derived classes can be instantiated
template<class V >
bool includesindexset (const V &y)
 return true if index sets coincide

Protected Attributes

size_type n
B * p
size_typej

Detailed Description

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

compressed_block_vector_unmanaged extends the compressed 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 A Dune::compressed_block_vector_unmanaged< B, A >::allocator_type

export the allocator type

template<class B, class A = std::allocator<B>>
typedef B Dune::compressed_block_vector_unmanaged< B, A >::block_type

export the type representing the components

template<class B , class A = std::allocator<B>>
typedef RealIterator<const B> Dune::compressed_base_array_unmanaged< B, A >::const_iterator
inherited

const_iterator class for sequential access

template<class B, class A = std::allocator<B>>
typedef compressed_base_array_unmanaged<B,A>::const_iterator Dune::compressed_block_vector_unmanaged< B, A >::ConstIterator

make iterators available as types

template<class B, class A = std::allocator<B>>
typedef B::field_type Dune::compressed_block_vector_unmanaged< B, A >::field_type

export the type representing the field

template<class B , class A = std::allocator<B>>
typedef RealIterator<B> Dune::compressed_base_array_unmanaged< B, A >::iterator
inherited

The iterator type.

template<class B, class A = std::allocator<B>>
typedef compressed_base_array_unmanaged<B,A>::iterator Dune::compressed_block_vector_unmanaged< B, A >::Iterator

make iterators available as types

template<class B , class A = std::allocator<B>>
typedef B Dune::compressed_base_array_unmanaged< B, A >::member_type
inherited

export the type representing the components

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

The type for the index access.

Constructor & Destructor Documentation

template<class B, class A = std::allocator<B>>
Dune::compressed_block_vector_unmanaged< B, A >::compressed_block_vector_unmanaged ( )
inlineprotected

make constructor protected, so only derived classes can be instantiated

Member Function Documentation

template<class B, class A = std::allocator<B>>
template<class V >
compressed_block_vector_unmanaged& Dune::compressed_block_vector_unmanaged< B, A >::axpy ( const field_type a,
const V &  y 
)
inline
template<class B , class A = std::allocator<B>>
iterator Dune::compressed_base_array_unmanaged< B, A >::beforeBegin ( )
inlineinherited
Returns
an iterator that is positioned before the first entry of the vector.

References Dune::compressed_base_array_unmanaged< B, A >::j, and Dune::compressed_base_array_unmanaged< B, A >::p.

template<class B , class A = std::allocator<B>>
const_iterator Dune::compressed_base_array_unmanaged< B, A >::beforeBegin ( ) const
inlineinherited
Returns
an iterator that is positioned before the first entry of the vector.

References Dune::compressed_base_array_unmanaged< B, A >::j, and Dune::compressed_base_array_unmanaged< B, A >::p.

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

References Dune::compressed_base_array_unmanaged< B, A >::j, Dune::compressed_base_array_unmanaged< B, A >::n, and Dune::compressed_base_array_unmanaged< B, A >::p.

template<class B , class A = std::allocator<B>>
const_iterator Dune::compressed_base_array_unmanaged< B, A >::beforeEnd ( ) const
inlineinherited
Returns
an iterator that is positioned before the end iterator of the vector. i.e. at the last element.

References Dune::compressed_base_array_unmanaged< B, A >::j, Dune::compressed_base_array_unmanaged< B, A >::n, and Dune::compressed_base_array_unmanaged< B, A >::p.

template<class B , class A = std::allocator<B>>
iterator Dune::compressed_base_array_unmanaged< B, A >::begin ( )
inlineinherited
template<class B , class A = std::allocator<B>>
const_iterator Dune::compressed_base_array_unmanaged< B, A >::begin ( ) const
inlineinherited
template<class B, class A = std::allocator<B>>
size_type Dune::compressed_block_vector_unmanaged< B, A >::dim ( ) const
inline
template<class B , class A = std::allocator<B>>
iterator Dune::compressed_base_array_unmanaged< B, A >::end ( )
inlineinherited
template<class B , class A = std::allocator<B>>
const_iterator Dune::compressed_base_array_unmanaged< B, A >::end ( ) const
inlineinherited
template<class B , class A = std::allocator<B>>
iterator Dune::compressed_base_array_unmanaged< B, A >::find ( size_type  i)
inlineinherited
template<class B , class A = std::allocator<B>>
const_iterator Dune::compressed_base_array_unmanaged< B, A >::find ( size_type  i) const
inlineinherited
template<class B, class A = std::allocator<B>>
template<class V >
bool Dune::compressed_block_vector_unmanaged< B, A >::includesindexset ( const V &  y)
inlineprotected
template<class B, class A = std::allocator<B>>
double Dune::compressed_block_vector_unmanaged< B, A >::infinity_norm ( ) const
inline

infinity norm (maximum of absolute values of entries)

References Dune::compressed_base_array_unmanaged< B, A >::n, and Dune::compressed_base_array_unmanaged< B, A >::p.

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

simplified infinity norm (uses Manhattan norm for complex values)

References Dune::compressed_base_array_unmanaged< B, A >::n, and Dune::compressed_base_array_unmanaged< B, A >::p.

template<class B, class A = std::allocator<B>>
size_type Dune::compressed_block_vector_unmanaged< B, A >::N ( ) const
inline

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

References Dune::compressed_base_array_unmanaged< B, A >::n.

Referenced by Dune::CompressedBlockVectorWindow< B, A >::operator=().

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

one norm (sum over absolute values of entries)

References Dune::compressed_base_array_unmanaged< B, A >::n, and Dune::compressed_base_array_unmanaged< B, A >::p.

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

simplified one norm (uses Manhattan norm for complex values)

References Dune::compressed_base_array_unmanaged< B, A >::n, and Dune::compressed_base_array_unmanaged< B, A >::p.

template<class B, class A = std::allocator<B>>
field_type Dune::compressed_block_vector_unmanaged< B, A >::operator* ( const compressed_block_vector_unmanaged< B, A > &  y) const
inline
template<class B, class A = std::allocator<B>>
compressed_block_vector_unmanaged& Dune::compressed_block_vector_unmanaged< B, A >::operator*= ( const field_type k)
inline
template<class B, class A = std::allocator<B>>
template<class V >
compressed_block_vector_unmanaged& Dune::compressed_block_vector_unmanaged< B, A >::operator+= ( const V &  y)
inline
template<class B, class A = std::allocator<B>>
template<class V >
compressed_block_vector_unmanaged& Dune::compressed_block_vector_unmanaged< B, A >::operator-= ( const V &  y)
inline
template<class B, class A = std::allocator<B>>
compressed_block_vector_unmanaged& Dune::compressed_block_vector_unmanaged< B, A >::operator/= ( const field_type k)
inline
template<class B, class A = std::allocator<B>>
compressed_block_vector_unmanaged& Dune::compressed_block_vector_unmanaged< B, A >::operator= ( const field_type k)
inline
template<class B , class A = std::allocator<B>>
B& Dune::compressed_base_array_unmanaged< B, A >::operator[] ( size_type  i)
inlineinherited
template<class B , class A = std::allocator<B>>
const B& Dune::compressed_base_array_unmanaged< B, A >::operator[] ( size_type  i) const
inlineinherited
template<class B , class A = std::allocator<B>>
size_type Dune::compressed_base_array_unmanaged< B, A >::size ( ) const
inlineinherited

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

References Dune::compressed_base_array_unmanaged< B, A >::n.

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

two norm sqrt(sum over squared values of entries)

References Dune::compressed_base_array_unmanaged< B, A >::n, and Dune::compressed_base_array_unmanaged< B, A >::p.

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

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

References Dune::compressed_base_array_unmanaged< B, A >::n, and Dune::compressed_base_array_unmanaged< B, A >::p.

Member Data Documentation

template<class B , class A = std::allocator<B>>
size_type* Dune::compressed_base_array_unmanaged< B, A >::j
protectedinherited
template<class B , class A = std::allocator<B>>
size_type Dune::compressed_base_array_unmanaged< B, A >::n
protectedinherited
template<class B , class A = std::allocator<B>>
B* Dune::compressed_base_array_unmanaged< B, A >::p
protectedinherited

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