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

A block-tridiagonal matrix. More...

#include <dune/istl/btdmatrix.hh>

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

Public Types

using field_type = typename Imp::BlockTraits< B >::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
 implement row_type with compressed vector More...
 
enum  BuildStage
 
enum  BuildMode
 we support two modes More...
 
typedef Imp::CompressedBlockVectorWindow< B, std::allocator< B > > row_type
 implement row_type with compressed vector More...
 
typedef ::Dune::CompressionStatistics< size_typeCompressionStatistics
 The type for the statistics object returned by compress() More...
 
typedef RealRowIterator< row_typeiterator
 The iterator over the (mutable matrix rows. More...
 
typedef RealRowIterator< row_typeIterator
 
typedef Iterator RowIterator
 rename the iterators for easier access More...
 
typedef row_type::Iterator ColIterator
 Iterator for the entries of each row. More...
 
typedef RealRowIterator< const row_typeconst_iterator
 The const iterator over the matrix rows. More...
 
typedef RealRowIterator< const row_typeConstIterator
 
typedef ConstIterator ConstRowIterator
 rename the const row iterator for easier access More...
 
typedef row_type::ConstIterator ConstColIterator
 Const iterator to the entries of a row. More...
 

Public Member Functions

 BTDMatrix ()
 Default constructor. More...
 
 BTDMatrix (size_type size)
 
void setSize (size_type size)
 Resize the matrix. Invalidates the content! More...
 
BTDMatrixoperator= (const BTDMatrix &other)
 assignment More...
 
BTDMatrixoperator= (const field_type &k)
 assignment from scalar More...
 
template<class V >
void solve (V &x, const V &rhs) const
 Use the Thomas algorithm to solve the system Ax=b in O(n) time. More...
 
row_typeoperator[] (size_type i)
 random access to the rows More...
 
const row_typeoperator[] (size_type i) const
 same for read only access More...
 
Iterator begin ()
 Get iterator to first row. More...
 
ConstIterator begin () const
 Get const iterator to first row. More...
 
Iterator end ()
 Get iterator to one beyond last row. More...
 
ConstIterator end () const
 Get const iterator to one beyond last row. More...
 
Iterator beforeEnd ()
 
ConstIterator beforeEnd () const
 
Iterator beforeBegin ()
 
ConstIterator beforeBegin () const
 
void setBuildMode (BuildMode bm)
 Sets the build mode of the matrix. More...
 
void setSize (size_type rows, size_type columns, size_type nnz=0)
 Set the size of the matrix. More...
 
void setImplicitBuildModeParameters (size_type _avg, double compressionBufferSize)
 Set parameters needed for creation in implicit build mode. More...
 
CreateIterator createbegin ()
 get initial create iterator More...
 
CreateIterator createend ()
 get create iterator pointing to one after the last block More...
 
size_type getrowsize (size_type i) const
 get current number of indices in row i More...
 
void incrementrowsize (size_type i, size_type s=1)
 increment size of row i by s (1 by default) More...
 
void setIndices (size_type row, It begin, It end)
 Set all column indices for row from the given iterator range. More...
 
B & entry (size_type row, size_type col)
 Returns reference to entry (row,col) of the matrix. More...
 
CompressionStatistics compress ()
 Finishes the buildstage in implicit mode. More...
 
BCRSMatrixoperator*= (const field_type &k)
 vector space multiplication with scalar More...
 
BCRSMatrixoperator/= (const field_type &k)
 vector space division by scalar More...
 
BCRSMatrixoperator+= (const BCRSMatrix &b)
 Add the entries of another matrix to this one. More...
 
BCRSMatrixoperator-= (const BCRSMatrix &b)
 Subtract the entries of another matrix from this one. More...
 
BCRSMatrixaxpy (field_type alpha, const BCRSMatrix &b)
 Add the scaled entries of another matrix to this one. More...
 
void mv (const X &x, Y &y) const
 y = A x More...
 
void umv (const X &x, Y &y) const
 y += A x More...
 
void mmv (const X &x, Y &y) const
 y -= A x More...
 
void usmv (F &&alpha, const X &x, Y &y) const
 y += alpha A x More...
 
void mtv (const X &x, Y &y) const
 y = A^T x More...
 
void umtv (const X &x, Y &y) const
 y += A^T x More...
 
void mmtv (const X &x, Y &y) const
 y -= A^T x More...
 
void usmtv (const field_type &alpha, const X &x, Y &y) const
 y += alpha A^T x More...
 
void umhv (const X &x, Y &y) const
 y += A^H x More...
 
void mmhv (const X &x, Y &y) const
 y -= A^H x More...
 
void usmhv (const field_type &alpha, const X &x, Y &y) const
 y += alpha A^H x More...
 
FieldTraits< field_type >::real_type frobenius_norm2 () const
 square of frobenius norm, need for block recursion More...
 
FieldTraits< field_type >::real_type frobenius_norm () const
 frobenius norm: sqrt(sum over squared values of entries) More...
 
FieldTraits< ft >::real_type infinity_norm () const
 infinity norm (row sum norm, how to generalize for blocks?) More...
 
FieldTraits< ft >::real_type infinity_norm () const
 infinity norm (row sum norm, how to generalize for blocks?) More...
 
FieldTraits< ft >::real_type infinity_norm_real () const
 simplified infinity norm (uses Manhattan norm for complex values) More...
 
FieldTraits< ft >::real_type infinity_norm_real () const
 simplified infinity norm (uses Manhattan norm for complex values) More...
 
size_type N () const
 number of rows (counted in blocks) More...
 
size_type M () const
 number of columns (counted in blocks) More...
 
size_type nonzeroes () const
 number of blocks that are stored (the number of blocks that possibly are nonzero) More...
 
BuildStage buildStage () const
 The current build stage of the matrix. More...
 
BuildMode buildMode () const
 The currently selected build mode of the matrix. More...
 
bool exists (size_type i, size_type j) const
 return true if (i,j) is in pattern More...
 

Static Public Attributes

static constexpr auto blocklevel = blockLevel<B>()+1
 increment block level counter More...
 

Protected Types

typedef std::map< std::pair< size_type, size_type >, B > OverflowType
 

Protected Member Functions

void setWindowPointers (ConstRowIterator row)
 
void setColumnPointers (ConstRowIterator row)
 Copy row sizes from iterator range starting at row and set column index pointers for all rows. More...
 
void setDataPointers ()
 Set data pointers for all rows. More...
 
void copyWindowStructure (const BCRSMatrix &Mat)
 Copy the window structure from another matrix. More...
 
void deallocate (bool deallocateRows=true)
 deallocate memory of the matrix. More...
 
void allocate (size_type rows, size_type columns, size_type allocationSize, bool allocateRows, bool allocate_data)
 Allocate memory for the matrix structure. More...
 
void allocateData ()
 
void implicit_allocate (size_type _n, size_type _m)
 organizes allocation implicit mode calculates correct array size to be allocated and sets the the window pointers to their correct positions for insertion. internally uses allocate() for the real allocation. More...
 

Protected Attributes

BuildMode build_mode
 
BuildStage ready
 
std::allocator_traits< std::allocator< B > >::template rebind_alloc< B > allocator_
 
std::allocator_traits< std::allocator< B > >::template rebind_alloc< row_typerowAllocator_
 
std::allocator_traits< std::allocator< B > >::template rebind_alloc< size_typesizeAllocator_
 
size_type n
 
size_type m
 
size_type nnz_
 
size_type allocationSize_
 
row_typer
 
B * a
 
std::shared_ptr< size_typej_
 
size_type avg
 
double compressionBufferSize_
 
OverflowType overflow
 

Detailed Description

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

A block-tridiagonal matrix.

Todo:
It would be safer and more efficient to have a real implementation of a block-tridiagonal matrix and not just subclassing from BCRSMatrix. But that's quite a lot of work for that little advantage.

Member Typedef Documentation

◆ allocator_type

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

export the allocator type

◆ block_type

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

export the type representing the components

◆ ColIterator

typedef row_type::Iterator Dune::BCRSMatrix< B, std::allocator< B > >::ColIterator
inherited

Iterator for the entries of each row.

◆ CompressionStatistics

typedef ::Dune::CompressionStatistics<size_type> Dune::BCRSMatrix< B, std::allocator< B > >::CompressionStatistics
inherited

The type for the statistics object returned by compress()

◆ const_iterator

typedef RealRowIterator<const row_type> Dune::BCRSMatrix< B, std::allocator< B > >::const_iterator
inherited

The const iterator over the matrix rows.

◆ ConstColIterator

typedef row_type::ConstIterator Dune::BCRSMatrix< B, std::allocator< B > >::ConstColIterator
inherited

Const iterator to the entries of a row.

◆ ConstIterator

typedef RealRowIterator<const row_type> Dune::BCRSMatrix< B, std::allocator< B > >::ConstIterator
inherited

◆ ConstRowIterator

typedef ConstIterator Dune::BCRSMatrix< B, std::allocator< B > >::ConstRowIterator
inherited

rename the const row iterator for easier access

◆ field_type

template<class B , class A = std::allocator<B>>
using Dune::BTDMatrix< B, A >::field_type = typename Imp::BlockTraits<B>::field_type

export the type representing the field

◆ iterator

typedef RealRowIterator<row_type> Dune::BCRSMatrix< B, std::allocator< B > >::iterator
inherited

The iterator over the (mutable matrix rows.

◆ Iterator

typedef RealRowIterator<row_type> Dune::BCRSMatrix< B, std::allocator< B > >::Iterator
inherited

◆ OverflowType

typedef std::map<std::pair<size_type,size_type>, B> Dune::BCRSMatrix< B, std::allocator< B > >::OverflowType
protectedinherited

◆ row_type

typedef Imp::CompressedBlockVectorWindow<B,std::allocator< B > > Dune::BCRSMatrix< B, std::allocator< B > >::row_type
inherited

implement row_type with compressed vector

◆ RowIterator

typedef Iterator Dune::BCRSMatrix< B, std::allocator< B > >::RowIterator
inherited

rename the iterators for easier access

◆ size_type

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

implement row_type with compressed vector

The type for the index access and the size

Member Enumeration Documentation

◆ BuildMode

we support two modes

◆ BuildStage

Constructor & Destructor Documentation

◆ BTDMatrix() [1/2]

template<class B , class A = std::allocator<B>>
Dune::BTDMatrix< B, A >::BTDMatrix ( )
inline

Default constructor.

◆ BTDMatrix() [2/2]

template<class B , class A = std::allocator<B>>
Dune::BTDMatrix< B, A >::BTDMatrix ( size_type  size)
inlineexplicit

Member Function Documentation

◆ allocate()

void Dune::BCRSMatrix< B, std::allocator< B > >::allocate ( size_type  rows,
size_type  columns,
size_type  allocationSize,
bool  allocateRows,
bool  allocate_data 
)
inlineprotectedinherited

Allocate memory for the matrix structure.

Sets the number of rows and columns of the matrix and allocates the memory needed for the storage of the matrix entries.

Warning
After calling this methods on an already allocated (and probably setup matrix) results in all the structure and data being lost. Please call deallocate() before calling allocate in this case.
Parameters
rowThe number of rows the matrix should contain.
columnsthe number of columns the matrix should contain.
allocationSizeThe number of nonzero entries the matrix should hold (if omitted defaults to 0).
allocateRowWhether we have to allocate the row pointers, too. (Defaults to true)

◆ allocateData()

void Dune::BCRSMatrix< B, std::allocator< B > >::allocateData ( )
inlineprotectedinherited

◆ axpy()

BCRSMatrix& Dune::BCRSMatrix< B, std::allocator< B > >::axpy ( field_type  alpha,
const BCRSMatrix< B, std::allocator< B > > &  b 
)
inlineinherited

Add the scaled entries of another matrix to this one.

Matrix axpy operation: *this += alpha * b

Parameters
alphaScaling factor.
bThe matrix to add to this one. Its sparsity pattern has to be subset of the sparsity pattern of this matrix.

◆ beforeBegin() [1/2]

Iterator Dune::BCRSMatrix< B, std::allocator< B > >::beforeBegin ( )
inlineinherited
Returns
an iterator that is positioned before the first row of the matrix.

◆ beforeBegin() [2/2]

ConstIterator Dune::BCRSMatrix< B, std::allocator< B > >::beforeBegin ( ) const
inlineinherited
Returns
an iterator that is positioned before the first row of the matrix.

◆ beforeEnd() [1/2]

Iterator Dune::BCRSMatrix< B, std::allocator< B > >::beforeEnd ( )
inlineinherited
Returns
an iterator that is positioned before the end iterator of the rows, i.e. at the last row.

◆ beforeEnd() [2/2]

ConstIterator Dune::BCRSMatrix< B, std::allocator< B > >::beforeEnd ( ) const
inlineinherited
Returns
an iterator that is positioned before the end iterator of the rows. i.e. at the last row.

◆ begin() [1/2]

Iterator Dune::BCRSMatrix< B, std::allocator< B > >::begin ( )
inlineinherited

Get iterator to first row.

◆ begin() [2/2]

ConstIterator Dune::BCRSMatrix< B, std::allocator< B > >::begin ( ) const
inlineinherited

Get const iterator to first row.

◆ buildMode()

BuildMode Dune::BCRSMatrix< B, std::allocator< B > >::buildMode ( ) const
inlineinherited

The currently selected build mode of the matrix.

◆ buildStage()

BuildStage Dune::BCRSMatrix< B, std::allocator< B > >::buildStage ( ) const
inlineinherited

The current build stage of the matrix.

◆ compress()

CompressionStatistics Dune::BCRSMatrix< B, std::allocator< B > >::compress ( )
inlineinherited

Finishes the buildstage in implicit mode.

Performs compression of index and data arrays with linear complexity in the number of nonzeroes.

After calling this method, the matrix is in the built state and no more entries can be added.

Returns
An object with some statistics about the compression for future optimization.

◆ copyWindowStructure()

void Dune::BCRSMatrix< B, std::allocator< B > >::copyWindowStructure ( const BCRSMatrix< B, std::allocator< B > > &  Mat)
inlineprotectedinherited

Copy the window structure from another matrix.

◆ createbegin()

CreateIterator Dune::BCRSMatrix< B, std::allocator< B > >::createbegin ( )
inlineinherited

get initial create iterator

◆ createend()

CreateIterator Dune::BCRSMatrix< B, std::allocator< B > >::createend ( )
inlineinherited

get create iterator pointing to one after the last block

◆ deallocate()

void Dune::BCRSMatrix< B, std::allocator< B > >::deallocate ( bool  deallocateRows = true)
inlineprotectedinherited

deallocate memory of the matrix.

Parameters
deallocateRowsWhether we have to deallocate the row pointers, too. If false they will not be touched. (Defaults to true).

◆ end() [1/2]

Iterator Dune::BCRSMatrix< B, std::allocator< B > >::end ( )
inlineinherited

Get iterator to one beyond last row.

◆ end() [2/2]

ConstIterator Dune::BCRSMatrix< B, std::allocator< B > >::end ( ) const
inlineinherited

Get const iterator to one beyond last row.

◆ entry()

B& Dune::BCRSMatrix< B, std::allocator< B > >::entry ( size_type  row,
size_type  col 
)
inlineinherited

Returns reference to entry (row,col) of the matrix.

This method can only be used when the matrix is in implicit building mode.

A reference to entry (row, col) of the matrix is returned. If entry (row, col) is accessed for the first time, it is created on the fly.

This method can only be used while building the matrix, after compression operator[] gives a much better performance.

◆ exists()

bool Dune::BCRSMatrix< B, std::allocator< B > >::exists ( size_type  i,
size_type  j 
) const
inlineinherited

return true if (i,j) is in pattern

◆ frobenius_norm()

FieldTraits<field_type>::real_type Dune::BCRSMatrix< B, std::allocator< B > >::frobenius_norm ( ) const
inlineinherited

frobenius norm: sqrt(sum over squared values of entries)

◆ frobenius_norm2()

FieldTraits<field_type>::real_type Dune::BCRSMatrix< B, std::allocator< B > >::frobenius_norm2 ( ) const
inlineinherited

square of frobenius norm, need for block recursion

◆ getrowsize()

size_type Dune::BCRSMatrix< B, std::allocator< B > >::getrowsize ( size_type  i) const
inlineinherited

get current number of indices in row i

◆ implicit_allocate()

void Dune::BCRSMatrix< B, std::allocator< B > >::implicit_allocate ( size_type  _n,
size_type  _m 
)
inlineprotectedinherited

organizes allocation implicit mode calculates correct array size to be allocated and sets the the window pointers to their correct positions for insertion. internally uses allocate() for the real allocation.

◆ incrementrowsize()

void Dune::BCRSMatrix< B, std::allocator< B > >::incrementrowsize ( size_type  i,
size_type  s = 1 
)
inlineinherited

increment size of row i by s (1 by default)

◆ infinity_norm() [1/2]

FieldTraits<ft>::real_type Dune::BCRSMatrix< B, std::allocator< B > >::infinity_norm ( ) const
inlineinherited

infinity norm (row sum norm, how to generalize for blocks?)

◆ infinity_norm() [2/2]

FieldTraits<ft>::real_type Dune::BCRSMatrix< B, std::allocator< B > >::infinity_norm ( ) const
inlineinherited

infinity norm (row sum norm, how to generalize for blocks?)

◆ infinity_norm_real() [1/2]

FieldTraits<ft>::real_type Dune::BCRSMatrix< B, std::allocator< B > >::infinity_norm_real ( ) const
inlineinherited

simplified infinity norm (uses Manhattan norm for complex values)

◆ infinity_norm_real() [2/2]

FieldTraits<ft>::real_type Dune::BCRSMatrix< B, std::allocator< B > >::infinity_norm_real ( ) const
inlineinherited

simplified infinity norm (uses Manhattan norm for complex values)

◆ M()

size_type Dune::BCRSMatrix< B, std::allocator< B > >::M ( ) const
inlineinherited

number of columns (counted in blocks)

◆ mmhv()

void Dune::BCRSMatrix< B, std::allocator< B > >::mmhv ( const X &  x,
Y &  y 
) const
inlineinherited

y -= A^H x

◆ mmtv()

void Dune::BCRSMatrix< B, std::allocator< B > >::mmtv ( const X &  x,
Y &  y 
) const
inlineinherited

y -= A^T x

◆ mmv()

void Dune::BCRSMatrix< B, std::allocator< B > >::mmv ( const X &  x,
Y &  y 
) const
inlineinherited

y -= A x

◆ mtv()

void Dune::BCRSMatrix< B, std::allocator< B > >::mtv ( const X &  x,
Y &  y 
) const
inlineinherited

y = A^T x

◆ mv()

void Dune::BCRSMatrix< B, std::allocator< B > >::mv ( const X &  x,
Y &  y 
) const
inlineinherited

y = A x

◆ N()

size_type Dune::BCRSMatrix< B, std::allocator< B > >::N ( ) const
inlineinherited

number of rows (counted in blocks)

◆ nonzeroes()

size_type Dune::BCRSMatrix< B, std::allocator< B > >::nonzeroes ( ) const
inlineinherited

number of blocks that are stored (the number of blocks that possibly are nonzero)

◆ operator*=()

BCRSMatrix& Dune::BCRSMatrix< B, std::allocator< B > >::operator*= ( const field_type k)
inlineinherited

vector space multiplication with scalar

◆ operator+=()

BCRSMatrix& Dune::BCRSMatrix< B, std::allocator< B > >::operator+= ( const BCRSMatrix< B, std::allocator< B > > &  b)
inlineinherited

Add the entries of another matrix to this one.

Parameters
bThe matrix to add to this one. Its sparsity pattern has to be subset of the sparsity pattern of this matrix.

◆ operator-=()

BCRSMatrix& Dune::BCRSMatrix< B, std::allocator< B > >::operator-= ( const BCRSMatrix< B, std::allocator< B > > &  b)
inlineinherited

Subtract the entries of another matrix from this one.

Parameters
bThe matrix to subtract from this one. Its sparsity pattern has to be subset of the sparsity pattern of this matrix.

◆ operator/=()

BCRSMatrix& Dune::BCRSMatrix< B, std::allocator< B > >::operator/= ( const field_type k)
inlineinherited

vector space division by scalar

◆ operator=() [1/2]

template<class B , class A = std::allocator<B>>
BTDMatrix& Dune::BTDMatrix< B, A >::operator= ( const BTDMatrix< B, A > &  other)
inline

assignment

◆ operator=() [2/2]

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

assignment from scalar

◆ operator[]() [1/2]

row_type& Dune::BCRSMatrix< B, std::allocator< B > >::operator[] ( size_type  i)
inlineinherited

random access to the rows

◆ operator[]() [2/2]

const row_type& Dune::BCRSMatrix< B, std::allocator< B > >::operator[] ( size_type  i) const
inlineinherited

same for read only access

◆ setBuildMode()

void Dune::BCRSMatrix< B, std::allocator< B > >::setBuildMode ( BuildMode  bm)
inlineinherited

Sets the build mode of the matrix.

Parameters
bmThe build mode to use.

◆ setColumnPointers()

void Dune::BCRSMatrix< B, std::allocator< B > >::setColumnPointers ( ConstRowIterator  row)
inlineprotectedinherited

Copy row sizes from iterator range starting at row and set column index pointers for all rows.

This method does not modify the data pointers, as those are set only after building the pattern (to allow for a delayed allocation).

◆ setDataPointers()

void Dune::BCRSMatrix< B, std::allocator< B > >::setDataPointers ( )
inlineprotectedinherited

Set data pointers for all rows.

This method assumes that column pointers and row sizes have been correctly set up by a prior call to setColumnPointers().

◆ setImplicitBuildModeParameters()

void Dune::BCRSMatrix< B, std::allocator< B > >::setImplicitBuildModeParameters ( size_type  _avg,
double  compressionBufferSize 
)
inlineinherited

Set parameters needed for creation in implicit build mode.

Use this method before setSize() to define storage behaviour of a matrix in implicit build mode

Parameters
_avgexpected average number of entries per row
compressionBufferSizefraction of _n*_avg which is expected to be needed for elements that exceed _avg entries per row.

◆ setIndices()

void Dune::BCRSMatrix< B, std::allocator< B > >::setIndices ( size_type  row,
It  begin,
It  end 
)
inlineinherited

Set all column indices for row from the given iterator range.

The iterator range has to be of the same length as the previously set row size. The entries in the iterator range do not have to be in any particular order, but must not contain duplicate values.

Calling this method overwrites any previously set column indices!

◆ setSize() [1/2]

void Dune::BCRSMatrix< B, std::allocator< B > >::setSize ( size_type  rows,
size_type  columns,
size_type  nnz = 0 
)
inlineinherited

Set the size of the matrix.

Sets the number of rows and columns of the matrix and allocates the memory needed for the storage of the matrix entries.

Warning
After calling this methods on an already allocated (and probably setup matrix) results in all the structure and data being deleted. I.~e. one has to setup the matrix again.
Parameters
rowsThe number of rows the matrix should contain.
columnsthe number of columns the matrix should contain.
nnzThe number of nonzero entries the matrix should hold (if omitted defaults to 0). Must be omitted in implicit mode.

◆ setSize() [2/2]

template<class B , class A = std::allocator<B>>
void Dune::BTDMatrix< B, A >::setSize ( size_type  size)
inline

Resize the matrix. Invalidates the content!

◆ setWindowPointers()

void Dune::BCRSMatrix< B, std::allocator< B > >::setWindowPointers ( ConstRowIterator  row)
inlineprotectedinherited

◆ solve()

template<class B , class A = std::allocator<B>>
template<class V >
void Dune::BTDMatrix< B, A >::solve ( V &  x,
const V &  rhs 
) const
inline

Use the Thomas algorithm to solve the system Ax=b in O(n) time.

Exceptions
ISTLErrorif the matrix is singular

◆ umhv()

void Dune::BCRSMatrix< B, std::allocator< B > >::umhv ( const X &  x,
Y &  y 
) const
inlineinherited

y += A^H x

◆ umtv()

void Dune::BCRSMatrix< B, std::allocator< B > >::umtv ( const X &  x,
Y &  y 
) const
inlineinherited

y += A^T x

◆ umv()

void Dune::BCRSMatrix< B, std::allocator< B > >::umv ( const X &  x,
Y &  y 
) const
inlineinherited

y += A x

◆ usmhv()

void Dune::BCRSMatrix< B, std::allocator< B > >::usmhv ( const field_type alpha,
const X &  x,
Y &  y 
) const
inlineinherited

y += alpha A^H x

◆ usmtv()

void Dune::BCRSMatrix< B, std::allocator< B > >::usmtv ( const field_type alpha,
const X &  x,
Y &  y 
) const
inlineinherited

y += alpha A^T x

◆ usmv()

void Dune::BCRSMatrix< B, std::allocator< B > >::usmv ( F &&  alpha,
const X &  x,
Y &  y 
) const
inlineinherited

y += alpha A x

Member Data Documentation

◆ a

B* Dune::BCRSMatrix< B, std::allocator< B > >::a
protectedinherited

◆ allocationSize_

size_type Dune::BCRSMatrix< B, std::allocator< B > >::allocationSize_
protectedinherited

◆ allocator_

std::allocator_traits<std::allocator< B > >::template rebind_alloc<B> Dune::BCRSMatrix< B, std::allocator< B > >::allocator_
protectedinherited

◆ avg

size_type Dune::BCRSMatrix< B, std::allocator< B > >::avg
protectedinherited

◆ blocklevel

template<class B , class A = std::allocator<B>>
constexpr auto Dune::BTDMatrix< B, A >::blocklevel = blockLevel<B>()+1
staticconstexpr

increment block level counter

◆ build_mode

BuildMode Dune::BCRSMatrix< B, std::allocator< B > >::build_mode
protectedinherited

◆ compressionBufferSize_

double Dune::BCRSMatrix< B, std::allocator< B > >::compressionBufferSize_
protectedinherited

◆ j_

std::shared_ptr<size_type> Dune::BCRSMatrix< B, std::allocator< B > >::j_
protectedinherited

◆ m

size_type Dune::BCRSMatrix< B, std::allocator< B > >::m
protectedinherited

◆ n

size_type Dune::BCRSMatrix< B, std::allocator< B > >::n
protectedinherited

◆ nnz_

size_type Dune::BCRSMatrix< B, std::allocator< B > >::nnz_
mutableprotectedinherited

◆ overflow

OverflowType Dune::BCRSMatrix< B, std::allocator< B > >::overflow
protectedinherited

◆ r

row_type* Dune::BCRSMatrix< B, std::allocator< B > >::r
protectedinherited

◆ ready

BuildStage Dune::BCRSMatrix< B, std::allocator< B > >::ready
protectedinherited

◆ rowAllocator_

std::allocator_traits<std::allocator< B > >::template rebind_alloc<row_type> Dune::BCRSMatrix< B, std::allocator< B > >::rowAllocator_
protectedinherited

◆ sizeAllocator_

std::allocator_traits<std::allocator< B > >::template rebind_alloc<size_type> Dune::BCRSMatrix< B, std::allocator< B > >::sizeAllocator_
protectedinherited

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