Loading...
Searching...
No Matches
Dune::BlockVector< B, A > Class Template Reference
Iterative Solvers Template Library (ISTL) » Sparse Matrix and Vector classes

A vector of blocks with memory management. More...

`#include <dune/istl/bvector.hh>`

Inheritance diagram for Dune::BlockVector< B, A >:

## Public Types

using | field_type = typename Imp::BlockTraits<B>::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 type for the index access.
typedef Imp::block_vector_unmanaged< B, size_type >::Iterator | Iterator
| make iterators available as types
typedef Imp::block_vector_unmanaged< B, size_type >::ConstIterator | ConstIterator
| make iterators available as types

## Public Member Functions

| BlockVector ()
| makes empty vector
| BlockVector (size_type _n)
| make vector with _n components
| BlockVector (std::initializer_list< B > const &l)
| Construct from a std::initializer_list.
template<typename S>
| BlockVector (size_type _n, S _capacity)
| Make vector with _n components but preallocating capacity components.
void | reserve (size_type capacity)
| Reserve space.
size_type | capacity () const
| Get the capacity of the vector.
void | resize (size_type size)
| Resize the vector.
| BlockVector (const BlockVector &a) noexcept(noexcept(std::declval< BlockVector >().storage_=a.storage_))
| copy constructor
| BlockVector (BlockVector &&a) noexcept(noexcept(std::declval< BlockVector >().swap(a)))
| move constructor
BlockVector & | operator= (const BlockVector &a) noexcept(noexcept(std::declval< BlockVector >().storage_=a.storage_))
| assignment
BlockVector & | operator= (BlockVector &&a) noexcept(noexcept(std::declval< BlockVector >().swap(a)))
| move assignment
void | swap (BlockVector &other) noexcept(noexcept(std::declval< BlockVector & >().storage_.swap(other.storage_)))
| swap operation
BlockVector & | operator= (const field_type &k)
| assign from scalar

## Detailed Description

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

A vector of blocks with memory management.

BlockVector adds memory management with ordinary copy semantics to the block_vector_unmanaged template.

    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::BlockVector< B, A >::allocator_type

export the allocator type

## block_type

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

typedef B Dune::BlockVector< B, A >::block_type

export the type representing the components

## ConstIterator

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

typedef Imp::block_vector_unmanaged<B,size_type>::ConstIterator Dune::BlockVector< B, A >::ConstIterator

make iterators available as types

## field_type

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

using Dune::BlockVector< B, A >::field_type = typename Imp::BlockTraits<B>::field_type

export the type representing the field

## Iterator

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

typedef Imp::block_vector_unmanaged<B,size_type>::Iterator Dune::BlockVector< B, A >::Iterator

make iterators available as types

## size_type

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

typedef A::size_type Dune::BlockVector< B, A >::size_type

The type for the index access.

## Constructor & Destructor Documentation

## BlockVector() [1/6]

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

Dune::BlockVector< B, A >::BlockVector | ( |  | ) |

inline

makes empty vector

## BlockVector() [2/6]

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

Dune::BlockVector< B, A >::BlockVector | ( | size_type | _n | ) |

inline explicit

make vector with _n components

## BlockVector() [3/6]

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

Dune::BlockVector< B, A >::BlockVector | ( | std::initializer_list< B > const & | l | ) |

inline

Construct from a std::initializer_list.

## BlockVector() [4/6]

template<class B, class A = std::allocator<B>>
template<typename S>

Dune::BlockVector< B, A >::BlockVector | ( | size_type | _n,
|  | S | _capacity )

inline

Make vector with _n components but preallocating capacity components.

If _n > capacity then space for _n entries is allocated.

Note
  This constructor is somewhat dangerous. People may be tempted to write something like
  BlockVector<FieldVector<double,1> > my_vector(100,0);
  Dune::BlockVector::BlockVector
  BlockVector()
  makes empty vector
  Definition bvector.hh:418
  expecting to obtain a vector of 100 doubles initialized with zero. However, the code calls this constructor which tacitly does something else!

## BlockVector() [5/6]

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

Dune::BlockVector< B, A >::BlockVector | ( | const BlockVector< B, A > & | a | ) |

inline noexcept

copy constructor

## BlockVector() [6/6]

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

Dune::BlockVector< B, A >::BlockVector | ( | BlockVector< B, A > && | a | ) |

inline noexcept

move constructor

## Member Function Documentation

## capacity()

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

size_type Dune::BlockVector< B, A >::capacity | ( |  | ) | const

inline

Get the capacity of the vector.

I. e. the maximum number of elements the vector can hold.

Returns
  The capacity of the vector.

## operator=() [1/3]

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

BlockVector & Dune::BlockVector< B, A >::operator= | ( | BlockVector< B, A > && | a | ) |

inline noexcept

move assignment

## operator=() [2/3]

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

BlockVector & Dune::BlockVector< B, A >::operator= | ( | const BlockVector< B, A > & | a | ) |

inline noexcept

assignment

## operator=() [3/3]

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

BlockVector & Dune::BlockVector< B, A >::operator= | ( | const field_type & | k | ) |

inline

assign from scalar

## reserve()

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

void Dune::BlockVector< B, A >::reserve | ( | size_type | capacity | ) |

inline

Reserve space.

Allocate storage for up to capacity blocks. Resizing won't cause reallocation until the size exceeds the capacity

Parameters

  capacity | The maximum number of elements the vector needs to hold.

## resize()

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

void Dune::BlockVector< B, A >::resize | ( | size_type | size | ) |

inline

Resize the vector.

Resize the vector to the given number of blocks. Blocks below the given size are copied (moved if possible). Old blocks above the given size are destructed, new blocks above the given size are value-initialized.

Parameters

  size | The new number of blocks of the vector.

## swap()

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

void Dune::BlockVector< B, A >::swap | ( | BlockVector< B, A > & | other | ) |

inline noexcept

swap operation

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

- bvector.hh