Loading...
Searching...
No Matches
Dune::MatrixImp::DenseMatrixBase< B, A > Class Template Reference

A Vector of blocks with different blocksizes. More...

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

Inheritance diagram for Dune::MatrixImp::DenseMatrixBase< B, A >:

## Classes

class | Iterator
| Iterator class for sequential access. More...
class | ConstIterator
| ConstIterator class for sequential access. More...

## Public Types

using | field_type = typename Imp::BlockTraits<B>::field_type
| export the type representing the field
typedef A | allocator_type
| export the allocator type
typedef A::size_type | size_type
| The size type for the index access.
typedef BlockVector< B, A > | value_type
| Type of the elements of the outer vector, i.e., dynamic vectors of B.
typedef BlockVector< B, A > | block_type
| Same as value_type, here for historical reasons.
typedef Imp::BlockVectorWindow< B, A > | window_type
typedef window_type | reference
typedef const window_type | const_reference
using | iterator = Iterator
| Export the iterator type using std naming rules.
using | const_iterator = ConstIterator
| Export the const iterator type using std naming rules.

## Public Member Functions

| DenseMatrixBase ()
| DenseMatrixBase (size_type rows, size_type columns)
| DenseMatrixBase (const DenseMatrixBase &a)
| copy constructor, has copy semantics
| ~DenseMatrixBase ()
| free dynamic memory
void | resize (size_type rows, size_type columns)
| same effect as constructor with same argument
DenseMatrixBase & | operator= (const DenseMatrixBase &a)
| assignment
DenseMatrixBase & | operator= (const field_type &k)
| assign from scalar
reference | operator[] (size_type i)
| random access to blocks
const_reference | operator[] (size_type i) const
| same for read only access
Iterator | begin ()
| begin Iterator
Iterator | end ()
| end Iterator
Iterator | beforeEnd ()
Iterator | beforeBegin () const
Iterator | find (size_type i)
| random access returning iterator (end if not contained)
ConstIterator | find (size_type i) const
| random access returning iterator (end if not contained)
ConstIterator | begin () const
| begin ConstIterator
ConstIterator | end () const
| end ConstIterator
ConstIterator | beforeEnd () const
ConstIterator | rend () const
| end ConstIterator
size_type | N () const
| number of blocks in the vector (are of variable size here)

## Detailed Description

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

A Vector of blocks with different blocksizes.

This class started as a copy of VariableBlockVector, which used to be used for the internal memory managerment of the 'Matrix' class. However, that mechanism stopped working when I started using the RandomAccessIteratorFacade in VariableBlockVector (308dd85483108f8baaa4051251e2c75e2a9aed32, to make VariableBlockVector pass a number of tightened interface compliance tests), and I couldn't quite figure out how to fix that. However, using VariableBlockVector in Matrix internally was a hack anyway, so I simply took the working version of VariableBlockVector and copied it here under the new name of DenseMatrixBase. This is still hacky, but one step closer to an elegant solution.

## Member Typedef Documentation

## allocator_type

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

typedef A Dune::MatrixImp::DenseMatrixBase< B, A >::allocator_type

export the allocator type

## block_type

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

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

Same as value_type, here for historical reasons.

## const_iterator

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

using Dune::MatrixImp::DenseMatrixBase< B, A >::const_iterator = ConstIterator

Export the const iterator type using std naming rules.

## const_reference

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

typedef const window_type Dune::MatrixImp::DenseMatrixBase< B, A >::const_reference

## field_type

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

using Dune::MatrixImp::DenseMatrixBase< 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>>

using Dune::MatrixImp::DenseMatrixBase< B, A >::iterator = Iterator

Export the iterator type using std naming rules.

## reference

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

typedef window_type Dune::MatrixImp::DenseMatrixBase< B, A >::reference

## size_type

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

typedef A::size_type Dune::MatrixImp::DenseMatrixBase< B, A >::size_type

The size type for the index access.

## value_type

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

typedef BlockVector<B,A> Dune::MatrixImp::DenseMatrixBase< B, A >::value_type

Type of the elements of the outer vector, i.e., dynamic vectors of B.

Note that this is not the type referred to by the iterators and random access operators, which return proxy objects.

## window_type

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

typedef Imp::BlockVectorWindow<B,A> Dune::MatrixImp::DenseMatrixBase< B, A >::window_type

## Constructor & Destructor Documentation

## DenseMatrixBase() [1/3]

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

Dune::MatrixImp::DenseMatrixBase< B, A >::DenseMatrixBase | ( |  | ) |

inline

constructor without arguments makes empty vector, object cannot be used yet

## DenseMatrixBase() [2/3]

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

Dune::MatrixImp::DenseMatrixBase< B, A >::DenseMatrixBase | ( | size_type | rows,
|  | size_type | columns )

inline

make vector with given number of blocks each having a constant size, object is fully usable then.

Parameters

  rows | Number of rows
  columns | Number of columns

## DenseMatrixBase() [3/3]

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

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

inline

copy constructor, has copy semantics

## ~DenseMatrixBase()

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

Dune::MatrixImp::DenseMatrixBase< B, A >::~DenseMatrixBase | ( |  | ) |

inline

free dynamic memory

## Member Function Documentation

## beforeBegin()

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

Iterator Dune::MatrixImp::DenseMatrixBase< B, A >::beforeBegin | ( |  | ) | const

inline

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::MatrixImp::DenseMatrixBase< B, A >::beforeEnd | ( |  | ) |

inline

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

ConstIterator Dune::MatrixImp::DenseMatrixBase< B, A >::beforeEnd | ( |  | ) | const

inline

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::MatrixImp::DenseMatrixBase< B, A >::begin | ( |  | ) |

inline

begin Iterator

## begin() [2/2]

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

ConstIterator Dune::MatrixImp::DenseMatrixBase< B, A >::begin | ( |  | ) | const

inline

begin ConstIterator

## end() [1/2]

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

Iterator Dune::MatrixImp::DenseMatrixBase< B, A >::end | ( |  | ) |

inline

end Iterator

## end() [2/2]

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

ConstIterator Dune::MatrixImp::DenseMatrixBase< B, A >::end | ( |  | ) | const

inline

end ConstIterator

## find() [1/2]

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

Iterator Dune::MatrixImp::DenseMatrixBase< B, A >::find | ( | size_type | i | ) |

inline

random access returning iterator (end if not contained)

## find() [2/2]

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

ConstIterator Dune::MatrixImp::DenseMatrixBase< B, A >::find | ( | size_type | i | ) | const

inline

random access returning iterator (end if not contained)

## N()

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

size_type Dune::MatrixImp::DenseMatrixBase< B, A >::N | ( |  | ) | const

inline

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

## operator=() [1/2]

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

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

inline

assignment

## operator=() [2/2]

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

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

inline

assign from scalar

## operator[]() [1/2]

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

reference Dune::MatrixImp::DenseMatrixBase< B, A >::operator[] | ( | size_type | i | ) |

inline

random access to blocks

## operator[]() [2/2]

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

const_reference Dune::MatrixImp::DenseMatrixBase< B, A >::operator[] | ( | size_type | i | ) | const

inline

same for read only access

## rend()

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

ConstIterator Dune::MatrixImp::DenseMatrixBase< B, A >::rend | ( |  | ) | const

inline

end ConstIterator

## resize()

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

void Dune::MatrixImp::DenseMatrixBase< B, A >::resize | ( | size_type | rows,
|  | size_type | columns )

inline

same effect as constructor with same argument

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

- matrix.hh