GitLab

Add missing inline keyword to some basis factories

See merge request !335

[test] Disable deprecation of evaluate() interface in test

See merge request !332

By defining the macro, testing `interpolate(...)` with a function
supporting the od style function interface with `evaluate(domain, range)`
will not lead to a deprecation warning.

Remove dome deprecated code

See merge request !331

The `NodeIndexSet` interface was deprecated in 2.8 and meanwhile
removed. Not removing the concept was an oversight.

This was deprecated in 2.8

Add another missing include.

See merge request !330

Cleanup MultiIndex generation

See merge request !326

Cleanup stokes exmaple

See merge request !328

Directly build the `PreBasis` type instead of using the indirection
via `Imp:Imp::PreBasisFactory`.

The old solution was to first construct the nested `PreBasisFactory`
object relying on the fact that this does not store any information.
With the modified `PreBasis` interface this is hugely simplified,
since we can directly construct the `PreBasis` type from the `GridView`.
Now we can directly construct the global basis from the `GridView`.

This assumes that the `PreBasis` can be constructed from the `GridView`
which is now also true for the `CompositePreBasis`. Notice that this
does only work if the `PreBasis` does not depend on dynamic data
except the `GridView`. However this assumption was also made implicitly
before but in a much more hidden way. Furthermore it is satisfied for
`LagrangePreBasis` which is the only one supported currently.

By also providing deduction guides we can now write
```cpp
DefaultGlobalBasis(gridView, power<3>(composite(...)))
```
instead of
```cpp
makeBasis(gridView, power<3>(composite(...)))
```

This constructor is only available, if all child-`PreBasis`
classes can be constructed from a `GridView`. This is now
also tested for a nested `LagrangePreBasis`

This should allow to significantly simplify the basis
construction in the python bindings.

This modifies the following prebasis implementations:

* `PowerPreBasis`
* `CompositePreBasis`
* `LagrangePreBasis`
* `RannacherTurekPreBasis`
* `BrezziDouglasMariniPreBasis`
* `HierarchicalLagrangePreBasis`
* `LagrangeDGPreBasis`
* `NedelecPreBasis`
* `RaviartThomasPreBasis`
* `TaylorHoodPreBasis`
* `BSplinePreBasis`
* `TransformedIndexPreBasis`
*  `PeriodicIndexingTransformation`

In most implementations the named `*PreBasisFactory` class
was replaced by a simple lambda.

In some implementations one has to replace `size({})` by
`size()`, because the former no longer works with the templated
`size(prefix)` method.

For `BSplinePreBasis` this needs a small hack: Since there is already a `size(size_type)`
method, using

```cpp
  template<class SizePrefix>
  size_type size(const SizePrefix& prefix) const
```

would be to gready and has to be replaced by the more specific

```cpp
template<class ST, int i>
size_type size(const Dune::ReservedVector<ST, i>& prefix) const
```

This also implement deduction guides to simplify construction of
`TransformedIndexPreBasis`.

This changes the generation and forwarding of multi index types
and related information in the interfaces of the `PreBasis` and `PreBasisFactory`
and the implementation `DefaultGlobalBasis`.
In summary: The `PreBasis` now longer depends on the `MultiIndex` type
which allows to move all information about required size of the multi indices
to the `PreBasis`. Now the `DefaultGlobalBasis` is responsible to create
suitable indices for the `PreBasis` (instead of `makeBasis()`).
Changes in detail:

* Changes to `PreBasis`
  * The typedefs `PreBasis::MultiIndex` and `PreBasis::SizePrefix` are
    removed.
  * The `SizePrefix` argument type of `PreBasis::size()` is a now template parameter.
  * The `MultiIndex`-type is no longer handed to the `PreBasis`.
  * There are new constants `PreBasis::minMultiIndexSize` <=
    `PreBasis::maxMultiIndexSize` <= `PreBasis::multiIndexBufferSize`.
    They denote the minimal and maximal size of the handed out
    multi indices and the maximal intermediate size needed for
    building each multi index.
* Changes to `PreBasisFactory`
  * The `MultiIndex`-type is no longer a template argument of `PreBasisFactory::makePreBasis`.
  * `PreBasisFactory::requiredMultiIndexSize` is removed.
  * `PreBasisFactory` is now a simple callback supporting
    `preBasisFactory(gridView)` instead of
    `preBasisFactory.makePreBasis(gridView)`.
* Changes to `DefaultGlobalBasis` and `makeBasis` implementation:
  * `PreBasis` is build before `MultiIndex` type is constructed.
  * The `MultiIndex` type is constructed in the `DefaultGlobalBasis`
    instead of `makeBasis`.
  * `makeBasis<MultiIndex>` was removed. This could be re-added, if we
    make the `MultiIndex` and additional template parameter of
    `DefaultGlobalBasis` with the automatically generated type as
    default.

* Remove some useless code artifacts.
* Reorder typedefs such that the macro switch
  `BLOCKEDBASIS` is usable again.

Add missing include in ComposedGridFunction

See merge request !327

Remove deprecated support for Prebasis without indices method

See merge request !321

This removes support for such `PreBasis` implementations
not implementing `PreBasis::indices` from the `DefaultLocalView`
and the meta `PreBasis` implementations.
Hence all backward compatibility code and checks related to this
can also be removed.

Remove the typedef `PreBasis::IndexSet` and the method
`PreBasis::makeIndexSet()` from all `PreBasis` implementations.
These have all been fallbacks for the interface that has
been deprecated in 2.8 and are no longer needed.

[doc] Mention recent changes in CHANGELOG.md

See merge request !324

Add ComposedGridFunction

See merge request !316

Add utilities for std::reference_wrapper

See merge request !315

For given inner grid functions `g0`, ..., `gn` and an
outer function `f` this implements the grid function
mapping `x`  to `f(g0(x), ..., gn(x))`. It is assumed
that the grid functions are defined on the same
`EntitySet` and that their range type can be passed to
the outer function.

All functions are stored by value. Storing references
is possible using passing `std::ref(f)`. To resolve
extended methods internally this makes use of the
`Dune::Functions::resolveRef()` utility.

This adds the following helpers for handling `std::reference_wrapper`:

* A predicate `IsReferenceWrapper_v<R>` for detecting if
  `R` is a `std::reference_wrapper<T>`.
* A helper function `resolveRef` for resolving references
  wrapped in `std::reference_wrapper`. For type `T` providing
  a method `T::foo()` this allows to transparently use
  `resolveRef(t).foo()` if `t` is either a plain `T` or
  a `std::reference_wrapper<T>`.
* A type alias `ResolveRef_t<T>` to determine the resolved
  type for `T`.

Update changelog

See merge request !319

Deprecate treedata.hh

See merge request !317