Skip to content

GitLab

Commit 00898fc5 authored by Müller, Felix's avatar Müller, Felix
Browse files

Update old ref pages

parent c0c400c0
Hide whitespace changes
Inline Side-by-side
amdis/linearalgebra/MatrixFacade.hpp
View file @ 00898fc5
...@@ -18,7 +18,6 @@ namespace AMDiS ...@@ -18,7 +18,6 @@ namespace AMDiS
* to a row and column global basis. * to a row and column global basis.
* *
* \tparam T The coefficient type of the matrix * \tparam T The coefficient type of the matrix
* \tparam Pattern The type of the sparsity pattern
* \tparam MatrixImpl A linear-algebra backend for the matrix storage * \tparam MatrixImpl A linear-algebra backend for the matrix storage
**/ **/
template <class T, template <class> class MatrixImpl> template <class T, template <class> class MatrixImpl>
......
docs/reference/DOFVector.md
View file @ 00898fc5
...@@ -28,7 +28,7 @@ Defined in header [`<amdis/DOFVector.hpp>`](https://gitlab.mn.tu-dresden.de/amdi ...@@ -28,7 +28,7 @@ Defined in header [`<amdis/DOFVector.hpp>`](https://gitlab.mn.tu-dresden.de/amdi
```c++ ```c++
template <class GB, template <class GB,
class T = double, class T = double,
class Traits = BackendTraits<GB,T>> class Traits = BackendTraits<GB>>
class DOFVector class DOFVector
: public VectorFacade<T, Traits::template VectorImpl> : public VectorFacade<T, Traits::template VectorImpl>
``` ```
...@@ -68,37 +68,41 @@ The `value_type` is often the same as `T`, but might be just something similar, ...@@ -68,37 +68,41 @@ The `value_type` is often the same as `T`, but might be just something similar,
[`interpolate_noalias`](#function-dofvectorinterpolate) | Interpolation of GridFunction to DOFVector assuming no aliasing [`interpolate_noalias`](#function-dofvectorinterpolate) | Interpolation of GridFunction to DOFVector assuming no aliasing
[`operator<<`](#function-dofvectorinterpolate) | Operator for the interpolation [`operator<<`](#function-dofvectorinterpolate) | Operator for the interpolation
??? seealso "Functions inherited from [`VectorFacade`](../MatVecBase/#class-vectorfacade)" ??? seealso "Functions inherited from [`VectorFacade`](../MatVecFacade/#class-vectorfacade)"
Function | Descriptions Function | Descriptions
--------------------------------|--------------------------------------------- --------------------------------|---------------------------------------------
[`basis`](../MatVecBase#function-vectorbasebasis) | Return the GlobalBasis associated with the vector [`impl`](../MatVecFacade#function-vectorbasebackend) | Return the backend vector wrapper implementing the actual algebra
[`backend`](../MatVecBase#function-vectorbasebackend) | Return the backend vector wrapper implementing the actual algebra [`localSize,globalSize`](../MatVecFacade#function-vectorbasesize) | The number of entries in the local part of the vector
[`localSize,globalSize`](../MatVecBase#function-vectorbasesize) | The number of entries in the local part of the vector [`resize,resizeZero`](../MatVecFacade#function-vectorbaseglobalSize)| Resize the vector to the size of the basis
[`resize,resizeZero`](../MatVecBase#function-vectorbaseglobalSize)| Resize the vector to the size of the basis [`init`](../MatVecFacade#function-vectorbaseglobalSize) | Prepare the vector for insertion of values
[`init`](../MatVecBase#function-vectorbaseglobalSize) | Prepare the vector for insertion of values [`finish`](../MatVecFacade#function-vectorbaseglobalSize) | Finish the insertion of values
[`finish`](../MatVecBase#function-vectorbaseglobalSize) | Finish the insertion of values [`at`](../MatVecFacade#function-vectorbaseat) | Return the value of the vector at the given local index
[`at`](../MatVecBase#function-vectorbaseat) | Return the value of the vector at the given local index [`insert,set,add`](../MatVecFacade#function-vectorbaseinsert) | Insert a single value into the matrix
[`insert,set,add`](../MatVecBase#function-vectorbaseinsert) | Insert a single value into the matrix [`gather`](../MatVecFacade#function-vectorbasegather) | Extract values from the vector referring to the given local indices
[`gather`](../MatVecBase#function-vectorbasegather) | Extract values from the vector referring to the given local indices [`scatter`](../MatVecFacade#function-vectorbasescatter) | Insert a block of values into the vector
[`scatter`](../MatVecBase#function-vectorbasescatter) | Insert a block of values into the vector [`forEach`](../MatVecFacade#function-vectorbasescatter) | Apply a functor to each value at given indices
[`copy`](../MatVecBase#function-vectorbasescatter) | Copies a block of values into the vector
[`forEach`](../MatVecBase#function-vectorbasescatter) | Apply a functor to each value at given indices
## function `DOFVector::DOFVector` ## function `DOFVector::DOFVector`
```c++ ```c++
template <class Basis> template <class Basis>
DOFVector(Basis&& basis, DataTransferOperation op = INTERPOLATE) DOFVector(Basis&& basis, DataTransferOperation op = INTERPOLATE)
template <class GV, class PBF>
DOFVector(GV const& gridView, PBF const& preBasisFactory, DataTransferOperation op = INTERPOLATE)
``` ```
Constructs the DOFVector from a given global basis and optionally a DataTransferOperation that Constructs the DOFVector from a given global basis or a grid view and a basis factory, and optionally a DataTransferOperation that defines how the DOFVector is handled during grid adaption.
defines how the DOFVector is handled during grid adaption.
#### Arguments #### Arguments
`Basis basis` `Basis basis`
: Either a `shared_ptr` to the `GlobalBasis` type or anything that can be converted to that, e.g. a : Either a `shared_ptr` to the `GlobalBasis` type or anything that can be converted to that, e.g. a reference or a `unique_ptr`. References to lvalues are wrapped into non-destroying `shared_ptr`s whereas rvalue-references are moved into new basis objects.
reference or a `unique_ptr` or a dune-functions `DefaultGlobalBasis`. References to lavlues are
wrapped into non-destroying `shared_ptr`s whereas rvalue-references are moved into new basis objects. `GV gridView`
: A grid view provided by the grid
`PBF preBasisFactory`
: A factory to create a pre-basis, see [the ref page on GlobalBasis](../GlobalBasis#making-a-prebasis)
`DataTransferOperation op` `DataTransferOperation op`
: The operation performed during data-transfer, either `DataTransferOperation::INTERPOLATE` or `DataTransferOperation::NO_OPERATION` : The operation performed during data-transfer, either `DataTransferOperation::INTERPOLATE` or `DataTransferOperation::NO_OPERATION`
...@@ -316,10 +320,10 @@ A `DiscreteFunction` is the interpretation of a `DOFVector` as grid function. ...@@ -316,10 +320,10 @@ A `DiscreteFunction` is the interpretation of a `DOFVector` as grid function.
## function `DiscreteFunction::DiscreteFunction` ## function `DiscreteFunction::DiscreteFunction`
```c++ ```c++
// (1) // (1)
DiscreteFunction(DOFVector<GlobalBasis,T> const& dofVector, DiscreteFunction(DOFVector<GlobalBasis,T> const& dofVector, GlobalBasis const& basis,
TreePath const& treePath = {}) TreePath const& treePath = {})
// (2) // (2)
DiscreteFunction(DOFVector<GlobalBasis,T>& dofVector, DiscreteFunction(DOFVector<GlobalBasis,T>& dofVector, GlobalBasis const& basis,
TreePath const& treePath = {}) TreePath const& treePath = {})
``` ```
...@@ -331,6 +335,9 @@ only available for the const or mutable `is_const` template parameter specializa ...@@ -331,6 +335,9 @@ only available for the const or mutable `is_const` template parameter specializa
: The container storing the global coefficients. Is stored as pointer in the DiscreteFunction and thus must have a longer lifetime : The container storing the global coefficients. Is stored as pointer in the DiscreteFunction and thus must have a longer lifetime
than the DiscreteFunction. than the DiscreteFunction.
`GlobalBasis const& basis`
: The global basis associated with the dofvector.
`TreePath treePath` `TreePath treePath`
: A `Dune::TypeTree::HybridTreePath<...>` representing the coordinates of a node in the basis tree this DiscreteFunction is : A `Dune::TypeTree::HybridTreePath<...>` representing the coordinates of a node in the basis tree this DiscreteFunction is
defined on. The type of the treePath also defines the `Range` type of the DiscreteFunction. defined on. The type of the treePath also defines the `Range` type of the DiscreteFunction.
...@@ -421,7 +428,7 @@ DiscreteFunction& operator+=(Expr&& expr) ...@@ -421,7 +428,7 @@ DiscreteFunction& operator+=(Expr&& expr)
// (5) // (5)
template <class Expr> template <class Expr>
DiscreteFunction& operator+=(Expr&& expr) DiscreteFunction& operator-=(Expr&& expr)
``` ```
(1) Interpolation of a `GridFunction` (or Expression) to the subtree of the DOFVector, assuming that there is no (1) Interpolation of a `GridFunction` (or Expression) to the subtree of the DOFVector, assuming that there is no
...@@ -474,11 +481,13 @@ Defined in header [`<amdis/gridfunctions/DiscreteFunction.hpp>`](https://gitlab. ...@@ -474,11 +481,13 @@ Defined in header [`<amdis/gridfunctions/DiscreteFunction.hpp>`](https://gitlab.
template <class GlobalBasis, class ValueType, template <class GlobalBasis, class ValueType,
class PreTreePath = Dune::TypeTree::HybridTreePath<>> class PreTreePath = Dune::TypeTree::HybridTreePath<>>
auto makeDiscreteFunction(DOFVector<GlobalBasis, ValueType> const& dofVector, auto makeDiscreteFunction(DOFVector<GlobalBasis, ValueType> const& dofVector,
GlobalBasis const& basis,
PreTreePath const& preTreePath = {}) PreTreePath const& preTreePath = {})
// (2) // (2)
template <class GlobalBasis, class ValueType, template <class GlobalBasis, class ValueType,
class PreTreePath = Dune::TypeTree::HybridTreePath<>> class PreTreePath = Dune::TypeTree::HybridTreePath<>>
auto makeDiscreteFunction(DOFVector<GlobalBasis, ValueType>& dofVector, auto makeDiscreteFunction(DOFVector<GlobalBasis, ValueType>& dofVector,
GlobalBasis const& basis,
PreTreePath const& preTreePath = {}) PreTreePath const& preTreePath = {})
``` ```
...@@ -491,6 +500,9 @@ can be constructed from. ...@@ -491,6 +500,9 @@ can be constructed from.
: The container storing the global coefficients. Is stored as pointer in the DiscreteFunction and thus must have a longer lifetime : The container storing the global coefficients. Is stored as pointer in the DiscreteFunction and thus must have a longer lifetime
than the DiscreteFunction. than the DiscreteFunction.
`GlobalBasis const& basis`
: The global basis associated to dofVector.
`PreTreePath preTreePath` `PreTreePath preTreePath`
: A pree-tree path, a `Dune::TypeTree::HybridTreePath<...>` can be created from. : A pree-tree path, a `Dune::TypeTree::HybridTreePath<...>` can be created from.
......
docs/reference/MatVecBase.md → docs/reference/MatVecFacade.md
View file @ 00898fc5
# MatrixBase and VectorBase {: #group-matvecbase } # MatrixFacade and VectorFacade {: #group-matvecbase }
## Summary ## Summary
The class [`VectorBase`](#class-vectorbase) is a base class and interface class for all vectors associated to the The class [`VectorFacade`](#class-vectorfacade) is a base class and interface class for all vectors associated to the
indices of a global basis and, correspondingly, the class [`MatrixBase`](#class-matrixbase) is a base class and interface indices of a global basis and, correspondingly, the class [`MatrixFacade`](#class-matrixfacade) is a base class and interface
class for all matrices associated to the indices of a row and column global basis. class for all matrices associated to the indices of a row and column global basis.
### Classes ### Classes
Class | Descriptions Class | Descriptions
----------------------------------|--------------------------------------------- --------------------------------------|-----------------------------------------
[`MatrixBase`](#class-matrixbase) | Base class for vectors [`MatrixFacade`](#class-matrixfacade) | Base class for matrices
[`VectorBase`](#class-vectorbase) | Base class for Matrices [`VectorFacade`](#class-vectorfacade) | Base class for vectors
## class `MatrixBase` ## class `MatrixFacade`
Defined in header [`<amdis/linearalgebra/MatrixBase.hpp>`](https://gitlab.mn.tu-dresden.de/amdis/amdis-core/blob/master/amdis/linearalgebra/MatrixBase.hpp) Defined in header [`<amdis/linearalgebra/MatrixFacade.hpp>`](https://gitlab.mn.tu-dresden.de/amdis/amdis-core/blob/master/amdis/linearalgebra/MatrixFacade.hpp)
```c++ ```c++
template <class RowBasis, template <class T, template <class> class MatrixImpl>
class ColBasis, class MatrixFacade
class Backend>
class MatrixBase
``` ```
`MatrixBase` is an interface class for matrices storing additionally pointers to the row and column basis, `RowBasis` and `ColBasis`, respectively. `MatrixFacade` is an interface class for matrices storing the implementation and rediricting to its interface functions.
The template parameter `Backend` refers to the actual implementation of the matrix data-structure. The template parameter `T` defines the coefficient type of the matrix, `MatrixImpl` refers to the actual implementation of the matrix data-structure.
### Member Types ### Member Types
Member Type | Definition Member Type | Definition
--------------------------------|--------------------------------------------- --------------|---------------------------------------------------------------
`RowBasis` | The type of the finite element space / basis of the row `Impl` | The Linear-Algebra implementation used to store the assembled coefficients
`RowLocalView` | `typename RowBasis::LocalView`
`ColBasis` | The type of the finite element space / basis of the column
`ColLocalView` | `typename ColBasis::LocalView`
`Backend` | The Linear-Algebra backend used to store the assembled coefficients
## class `VectorBase` ## class `VectorFacade`
Defined in header [`<amdis/linearalgebra/VectorBase.hpp>`](https://gitlab.mn.tu-dresden.de/amdis/amdis-core/blob/master/amdis/linearalgebra/VectorBase.hpp) Defined in header [`<amdis/linearalgebra/VectorFacade.hpp>`](https://gitlab.mn.tu-dresden.de/amdis/amdis-core/blob/master/amdis/linearalgebra/VectorFacade.hpp)
```c++ ```c++
template <class Basis, template <class T, template <class> class VectorImpl>
class Backend> class VectorFacade
class VectorBase
``` ```
`VectorBase` is an interface class for vectors storing an additional pointer to the global basis, `Basis`. `VectorFacade` is an interface class for vectors storing the implementation and rediricting to its interface functions.
The template parameter `Backend` refers to the actual implementation of the vector data-structure. The template parameter `T` defines the coefficient type of the vector, `VectorImpl` refers to the actual implementation of the vector data-structure.
### Member Types ### Member Types
Member Type | Definition Member Type | Definition
--------------------------------|--------------------------------------------- -------------|----------------------------------------------------------------
`GlobalBasis` | The type of the functionspace basis `Impl` | The Linear-Algebra implementation used to store the assembled coefficients
`LocalView` | `typename GlobalBasis::LocalView`
`Backend` | The Linear-Algebra backend used to store the assembled coefficients
### Member functions ### Member functions
Function | Descriptions Function | Descriptions
--------------------------------|--------------------------------------------- --------------------------------|---------------------------------------------
[*(constructor)*](#function-vectorbasevectorbase) | Construct the VectorBase [*(constructor)*](#function-vectorfacadevectorfacade) | Construct the VectorFacade
[`basis`](#function-vectorbasebasis) | Return the GlobalBasis associated with the vector [`impl`](#function-vectorfacadeimpl) | Return the vector implementation
[`backend`](#function-vectorbasebackend) | Return the backend vector wrapper implementing the actual algebra
**Capacity** **Capacity**
Function | Descriptions Function | Descriptions
--------------------------------|--------------------------------------------- --------------------------------|---------------------------------------------
[`localSize,globalSize`](#function-vectorbasesize) | The number of entries in the local/global part of the vector [`localSize,globalSize`](#function-vectorfacadesize) | The number of entries in the local/global part of the vector
[`resize,resizeZero`](#function-vectorbaseresize) | Resize the vector to the size of the basis [`resize,resizeZero`](#function-vectorfacaderesize) | Resize the vector to the size of the basis
[`init`](#function-vectorbaseinit) | Prepare the vector for insertion of values [`init`](#function-vectorfacadeinit) | Prepare the vector for insertion of values
[`finish`](#function-vectorbasefinish) | Finish the insertion of values [`finish`](#function-vectorfacadefinish) | Finish the insertion of values
**Element access** **Element access**
Function | Descriptions Function | Descriptions
--------------------------------|--------------------------------------------- --------------------------------|---------------------------------------------
[`at`](#function-vectorbaseat) | Return the value of the vector at the given local index [`at`](#function-vectorfacadeat) | Return the value of the vector at the given local index
[`gather`](#function-vectorbasegather) | Extract values from the vector referring to the given local indices [`gather`](#function-vectorfacadegather) | Extract values from the vector referring to the given local indices
**Modifiers** **Modifiers**
Function | Descriptions Function | Descriptions
--------------------------------|--------------------------------------------- --------------------------------|---------------------------------------------
[`insert,set,add`](#function-vectorbaseinsert) | Insert a single value into the matrix (add or overwrite to existing value) [`insert,set,add`](#function-vectorfacadeinsert) | Insert a single value into the matrix (add or overwrite to existing value)
[`scatter`](#function-vectorbasescatter) | Insert a block of values into the vector [`scatter`](#function-vectorfacadescatter) | Insert a block of values into the vector
[`copy`](#function-vectorbasescatter) | Copies a block of values into the vector [`forEach`](#function-vectorfacadescatter) | Apply a functor to each value at given indices
[`forEach`](#function-vectorbasescatter) | Apply a functor to each value at given indices
## function `VectorBase::VectorBase` ## function `VectorFacade::VectorFacade`
```c++ ```c++
VectorBase(std::shared_ptr<GlobalBasis> basis) // (1) VectorFacade(GlobalBasis const& basis)
template <class GB>
VectorBase(GB&& basis) // (2)
``` ```
(1) Constructor that stores the `shared_ptr` of the global basis. (2) Constructor that forwards to (1) by wrapping reference Constructor that passes the global basis to the implementation.
into (non-destroying) `shared_ptr`.
#### Arguments
`GB basis`
: Reference (lvalue or rvalue) to a global basis. `GB` must be `Concepts::Similar` to the type `GlobalBasis`. If `basis` is a lvalue-reference,
it is wrapped into a non-destroying `shared_ptr`, if it is a rvalue-reference, it is moved into a new Object, created as `shared_ptr`.
See `Dune::wrap_or_move`.
#### Requirements
- `GB` must be similar to `GlobalBasis`, i.e., the same type up to const and reference qualifiers.
## function `VectorBase::basis`
```c++
std::shared_ptr<GlobalBasis> const& basis() const // (1)
std::shared_ptr<GlobalBasis> const& basis() // (2)
```
Return the basis associated to the vector
## function `VectorBase::backend` ## function `VectorFacade::impl`
```c++ ```c++
Backend const& backend() const // (1) Impl const& impl() const // (1)
Backend& backend() // (2) Impl& impl() // (2)
``` ```
Return the underlying linear algebra backend Return the underlying linear algebra implementation
## function `VectorBase::localSize,globalSize` {: #function-vectorbasesize } ## function `VectorFacade::localSize,globalSize` {: #function-vectorfacadesize }
```c++ ```c++
std::size_t localSize() const // (1) std::size_t localSize() const // (1)
std::size_t globalSize() const // (2) std::size_t globalSize() const // (2)
...@@ -137,7 +105,7 @@ std::size_t globalSize() const // (2) ...@@ -137,7 +105,7 @@ std::size_t globalSize() const // (2)
Return the number of entries in the (1) local part of the vector, or (2) in the global vector. Return the number of entries in the (1) local part of the vector, or (2) in the global vector.
## function `VectorBase::resize,resizeZero` {: #function-vectorbaseresize } ## function `VectorFacade::resize,resizeZero` {: #function-vectorfacaderesize }
```c++ ```c++
std::size_t resize() const // (1) std::size_t resize() const // (1)
std::size_t resizeZero() const // (2) std::size_t resizeZero() const // (2)
...@@ -145,25 +113,25 @@ std::size_t resizeZero() const // (2) ...@@ -145,25 +113,25 @@ std::size_t resizeZero() const // (2)
Resize the vector to the size of the basis (1) and in case of (2) also set all entries to zero. Resize the vector to the size of the basis (1) and in case of (2) also set all entries to zero.
## function `VectorBase::init` ## function `VectorFacade::init`
```c++ ```c++
void init(bool clear) void init(bool clear)
``` ```
Prepare the vector for insertion of values, finish the insertion with a call to [finish()](#function-vectorbasefinish). Prepare the vector for insertion of values, finish the insertion with a call to [finish()](#function-vectorfacadefinish).
#### Arguments #### Arguments
`bool clear` `bool clear`
: If true, sets the vector to zero before insertion : If true, sets the vector to zero before insertion
## function `VectorBase::finish` ## function `VectorFacade::finish`
```c++ ```c++
void finish() void finish()
``` ```
Finish the insertion of values. Must be called at the end of the insertion. See also [init()](#function-vectorbaseinit). Finish the insertion of values. Must be called at the end of the insertion. See also [init()](#function-vectorfacadeinit).
## function `VectorBase::at` {: #function-vectorbaseat } ## function `VectorFacade::at` {: #function-vectorfacadeat }
```c++ ```c++
template <class Index> template <class Index>
typename Backend::value_type at(Index const& dof) const typename Backend::value_type at(Index const& dof) const
...@@ -173,14 +141,14 @@ might be necessary. This is a collective communication operation. This communica ...@@ -173,14 +141,14 @@ might be necessary. This is a collective communication operation. This communica
unsynchronized state. unsynchronized state.
!!! note !!! note
Prefer a block operation to retrieve data, like [gather()](#function-vectorbasegather). Prefer a block operation to retrieve data, like [gather()](#function-vectorfacadegather).
#### Arguments #### Arguments
`Index dof` `Index dof`
: Any (Multi-)index type. Currently only flat multiindices are supported. This will be relaxed in future versions of the library. : Any (Multi-)index type. Currently only flat multiindices are supported. This will be relaxed in future versions of the library.
## function `VectorBase::gather` ## function `VectorFacade::gather`
```c++ ```c++
// (1) // (1)
template <class Node, class Buffer> template <class Node, class Buffer>
...@@ -196,7 +164,7 @@ indices are defined by (1) the `nodeIndices(localView, node)` or (2) the ...@@ -196,7 +164,7 @@ indices are defined by (1) the `nodeIndices(localView, node)` or (2) the
If the vector is not in synchronized state, collects all necessary values If the vector is not in synchronized state, collects all necessary values
possibly from neighboring processors. Gather can not be called during insertion possibly from neighboring processors. Gather can not be called during insertion
state. This must be closed using [finish()](#function-vectorbasefinish) before. state. This must be closed using [finish()](#function-vectorfacadefinish) before.
#### Arguments #### Arguments
`LocalView localView` `LocalView localView`
...@@ -216,7 +184,7 @@ state. This must be closed using [finish()](#function-vectorbasefinish) before. ...@@ -216,7 +184,7 @@ state. This must be closed using [finish()](#function-vectorbasefinish) before.
- **expects:** `node` is in `localView.tree()` - **expects:** `node` is in `localView.tree()`
## function `VectorBase::insert,set,add` {: #function-vectorbaseinsert } ## function `VectorFacade::insert,set,add` {: #function-vectorfacadeinsert }
```c++ ```c++
// (1) // (1)
template <class Index, class Assign = Assigner::plus_assign> template <class Index, class Assign = Assigner::plus_assign>
...@@ -236,12 +204,12 @@ of a vector. The insertion mode is determined by the `assign` functor. Use ...@@ -236,12 +204,12 @@ of a vector. The insertion mode is determined by the `assign` functor. Use
`Assigner::plus_assign` for adding values (default) or `Assigner::assign` `Assigner::plus_assign` for adding values (default) or `Assigner::assign`
for overwriting (setting) values. Different insertion modes must not be mixed! for overwriting (setting) values. Different insertion modes must not be mixed!
Insertion must be closed with a call to [finish()](#function-vectorbasefinish). Insertion must be closed with a call to [finish()](#function-vectorfacadefinish).
(2) and (3) are abbreviations for the general `insert()` method (1) by fixing the insertion mode. (2) and (3) are abbreviations for the general `insert()` method (1) by fixing the insertion mode.
!!! note !!! note
Prefer a block operation to insert data, like [scatter()](#function-vectorbasescatter). Prefer a block operation to insert data, like [scatter()](#function-vectorfacadescatter).
#### Arguments #### Arguments
`Index dof` `Index dof`
...@@ -254,7 +222,7 @@ Insertion must be closed with a call to [finish()](#function-vectorbasefinish). ...@@ -254,7 +222,7 @@ Insertion must be closed with a call to [finish()](#function-vectorbasefinish).
: An assignment functor with the signature `void operator()(T const& from, S&& to) const` : An assignment functor with the signature `void operator()(T const& from, S&& to) const`
## function `VectorBase::scatter` ## function `VectorFacade::scatter`
```c++ ```c++
// (1) // (1)
template <class Node, class NodeVector, class MaskRange, class Assign> template <class Node, class NodeVector, class MaskRange, class Assign>
...@@ -281,7 +249,7 @@ be forward iterable for at least `localVector.size()` elements. Does not ...@@ -281,7 +249,7 @@ be forward iterable for at least `localVector.size()` elements. Does not
need an `end()` method. See, e.g. `FakeContainer`. need an `end()` method. See, e.g. `FakeContainer`.
Insertion must be closed with a call to \ref finish(). It is not allowed Insertion must be closed with a call to \ref finish(). It is not allowed
to switch insertion mode before calling [finish()](#function-vectorbasefinish). to switch insertion mode before calling [finish()](#function-vectorfacadefinish).
(2) Same as (1) but all indices are inserted. (2) Same as (1) but all indices are inserted.
......
mkdocs.yml
View file @ 00898fc5
...@@ -22,7 +22,7 @@ nav: ...@@ -22,7 +22,7 @@ nav:
- Initfile: reference/Initfile.md - Initfile: reference/Initfile.md
- Operators: reference/Operators.md - Operators: reference/Operators.md
- Problem: reference/Problem.md - Problem: reference/Problem.md
- MatrixBase and VectorBase: reference/MatVecBase.md - MatrixFacade and VectorFacade: reference/MatVecFacade.md
- API Documentation: - API Documentation:
- Modules: api/modules.html - Modules: api/modules.html
- Namespaces: api/namespaces.html - Namespaces: api/namespaces.html
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment