dune-istl  2.5.0
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
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

Public Types

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

Public Member Functions

block_vector_unmanagedoperator= (const field_type &k)
 Assignment from a scalar. More...
 
block_vector_unmanagedoperator+= (const block_vector_unmanaged &y)
 vector space addition More...
 
block_vector_unmanagedoperator-= (const block_vector_unmanaged &y)
 vector space subtraction More...
 
block_vector_unmanagedoperator*= (const field_type &k)
 vector space multiplication with scalar More...
 
block_vector_unmanagedoperator/= (const field_type &k)
 vector space division by scalar More...
 
block_vector_unmanagedaxpy (const field_type &a, const block_vector_unmanaged &y)
 vector space axpy operation More...
 
template<class OtherB , class OtherA >
PromotionTraits< field_type, typename OtherB::field_type >::PromotedType operator* (const block_vector_unmanaged< OtherB, OtherA > &y) const
 indefinite vector dot product $\left (x^T \cdot y \right)$ which corresponds to Petsc's VecTDot More...
 
template<class OtherB , class OtherA >
PromotionTraits< field_type, typename OtherB::field_type >::PromotedType dot (const block_vector_unmanaged< OtherB, OtherA > &y) const
 vector dot product $\left (x^H \cdot y \right)$ which corresponds to Petsc's VecDot More...
 
FieldTraits< field_type >::real_type one_norm () const
 one norm (sum over absolute values of entries) More...
 
FieldTraits< field_type >::real_type one_norm_real () const
 simplified one norm (uses Manhattan norm for complex values) More...
 
FieldTraits< field_type >::real_type two_norm () const
 two norm sqrt(sum over squared values of entries) More...
 
FieldTraits< field_type >::real_type two_norm2 () const
 Square of the two-norm (the sum over the squared values of the entries) More...
 
template<typename ft = field_type, typename std::enable_if<!has_nan< ft >::value, int >::type = 0>
FieldTraits< ft >::real_type infinity_norm () const
 infinity norm (maximum of absolute values of entries) More...
 
template<typename ft = field_type, typename std::enable_if<!has_nan< ft >::value, int >::type = 0>
FieldTraits< ft >::real_type infinity_norm_real () const
 simplified infinity norm (uses Manhattan norm for complex values) More...
 
template<typename ft = field_type, typename std::enable_if< has_nan< ft >::value, int >::type = 0>
FieldTraits< ft >::real_type infinity_norm () const
 infinity norm (maximum of absolute values of entries) More...
 
template<typename ft = field_type, typename std::enable_if< has_nan< ft >::value, int >::type = 0>
FieldTraits< ft >::real_type infinity_norm_real () const
 simplified infinity norm (uses Manhattan norm for complex values) More...
 
size_type N () const
 number of blocks in the vector (are of size 1 here) More...
 
size_type dim () const
 dimension of the vector space More...
 
B & operator[] (size_type i)
 random access to blocks More...
 
const B & operator[] (size_type i) const
 same for read only access More...
 
iterator begin ()
 begin iterator More...
 
const_iterator begin () const
 begin const_iterator More...
 
iterator end ()
 end iterator More...
 
const_iterator end () const
 end const_iterator More...
 
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) More...
 
const_iterator find (size_type i) const
 random access returning iterator (end if not contained) More...
 
size_type size () const
 number of blocks in the array (are of size 1 here) More...
 

Protected Member Functions

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

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

◆ allocator_type

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

export the allocator type

◆ block_type

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

export the type representing the components

◆ const_iterator

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

◆ const_reference

template<class B, class A = std::allocator<B>>
typedef const B& Dune::block_vector_unmanaged< B, A >::const_reference

Type used for const references.

◆ ConstIterator

template<class B, class A = std::allocator<B>>
typedef base_array_unmanaged<B,A>::const_iterator Dune::block_vector_unmanaged< B, A >::ConstIterator

make iterators available as types

◆ field_type

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

export the type representing the field

◆ Iterator

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

make iterators available as types

◆ iterator

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

iterator type for sequential access

◆ member_type

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

◆ reference

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

Type used for references.

◆ size_type

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

The size type for the index access.

◆ value_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

◆ block_vector_unmanaged()

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

make constructor protected, so only derived classes can be instantiated

Member Function Documentation

◆ axpy()

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

◆ beforeBegin() [1/2]

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

◆ beforeBegin() [2/2]

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

◆ beforeEnd() [1/2]

template<class B, class A = std::allocator<B>>
iterator Dune::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.

◆ beforeEnd() [2/2]

template<class B, class A = std::allocator<B>>
const_iterator Dune::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.

◆ begin() [1/2]

template<class B, class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::begin ( )
inlineinherited

begin iterator

◆ begin() [2/2]

template<class B, class A = std::allocator<B>>
const_iterator Dune::base_array_unmanaged< B, A >::begin ( ) const
inlineinherited

begin const_iterator

◆ dim()

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

dimension of the vector space

◆ dot()

template<class B, class A = std::allocator<B>>
template<class OtherB , class OtherA >
PromotionTraits<field_type,typename OtherB::field_type>::PromotedType Dune::block_vector_unmanaged< B, A >::dot ( const block_vector_unmanaged< OtherB, OtherA > &  y) const
inline

vector dot product $\left (x^H \cdot y \right)$ which corresponds to Petsc's VecDot

http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Vec/VecDot.html

Parameters
yother (compatible) vector
Returns

◆ end() [1/2]

template<class B, class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::end ( )
inlineinherited

end iterator

◆ end() [2/2]

template<class B, class A = std::allocator<B>>
const_iterator Dune::base_array_unmanaged< B, A >::end ( ) const
inlineinherited

end const_iterator

◆ find() [1/2]

template<class B, class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::find ( size_type  i)
inlineinherited

random access returning iterator (end if not contained)

◆ find() [2/2]

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

random access returning iterator (end if not contained)

◆ infinity_norm() [1/2]

template<class B, class A = std::allocator<B>>
template<typename ft = field_type, typename std::enable_if<!has_nan< ft >::value, int >::type = 0>
FieldTraits<ft>::real_type Dune::block_vector_unmanaged< B, A >::infinity_norm ( ) const
inline

infinity norm (maximum of absolute values of entries)

◆ infinity_norm() [2/2]

template<class B, class A = std::allocator<B>>
template<typename ft = field_type, typename std::enable_if< has_nan< ft >::value, int >::type = 0>
FieldTraits<ft>::real_type Dune::block_vector_unmanaged< B, A >::infinity_norm ( ) const
inline

infinity norm (maximum of absolute values of entries)

◆ infinity_norm_real() [1/2]

template<class B, class A = std::allocator<B>>
template<typename ft = field_type, typename std::enable_if<!has_nan< ft >::value, int >::type = 0>
FieldTraits<ft>::real_type Dune::block_vector_unmanaged< B, A >::infinity_norm_real ( ) const
inline

simplified infinity norm (uses Manhattan norm for complex values)

◆ infinity_norm_real() [2/2]

template<class B, class A = std::allocator<B>>
template<typename ft = field_type, typename std::enable_if< has_nan< ft >::value, int >::type = 0>
FieldTraits<ft>::real_type Dune::block_vector_unmanaged< B, A >::infinity_norm_real ( ) const
inline

simplified infinity norm (uses Manhattan norm for complex values)

◆ N()

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

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

◆ one_norm()

template<class B, class A = std::allocator<B>>
FieldTraits<field_type>::real_type Dune::block_vector_unmanaged< B, A >::one_norm ( ) const
inline

one norm (sum over absolute values of entries)

◆ one_norm_real()

template<class B, class A = std::allocator<B>>
FieldTraits<field_type>::real_type Dune::block_vector_unmanaged< B, A >::one_norm_real ( ) const
inline

simplified one norm (uses Manhattan norm for complex values)

◆ operator*()

template<class B, class A = std::allocator<B>>
template<class OtherB , class OtherA >
PromotionTraits<field_type,typename OtherB::field_type>::PromotedType Dune::block_vector_unmanaged< B, A >::operator* ( const block_vector_unmanaged< OtherB, OtherA > &  y) const
inline

indefinite vector dot product $\left (x^T \cdot y \right)$ which corresponds to Petsc's VecTDot

http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Vec/VecTDot.html

Parameters
yother (compatible) vector
Returns

◆ operator*=()

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

◆ operator+=()

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

◆ operator-=()

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

◆ operator/=()

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

◆ operator=()

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

Assignment from a scalar.

◆ operator[]() [1/2]

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

random access to blocks

◆ operator[]() [2/2]

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

same for read only access

◆ size()

template<class B, class A = std::allocator<B>>
size_type Dune::base_array_unmanaged< B, A >::size ( ) const
inlineinherited

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

◆ two_norm()

template<class B, class A = std::allocator<B>>
FieldTraits<field_type>::real_type Dune::block_vector_unmanaged< B, A >::two_norm ( ) const
inline

two norm sqrt(sum over squared values of entries)

◆ two_norm2()

template<class B, class A = std::allocator<B>>
FieldTraits<field_type>::real_type Dune::block_vector_unmanaged< B, A >::two_norm2 ( ) const
inline

Square of the two-norm (the sum over the squared values of the entries)

Member Data Documentation

◆ n

template<class B, class A = std::allocator<B>>
size_type Dune::base_array_unmanaged< B, A >::n
protectedinherited

◆ p

template<class B, class A = std::allocator<B>>
B* Dune::base_array_unmanaged< B, A >::p
protectedinherited

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