1. 26 Jun, 2018 4 commits
  2. 22 Jun, 2018 3 commits
  3. 20 Jun, 2018 1 commit
  4. 19 Jun, 2018 14 commits
  5. 14 Jun, 2018 7 commits
    • Carsten Gräser's avatar
      Switch to compatible function rage · 55690705
      Carsten Gräser authored
      Having HierarchicNodeToRangeMap as default, you must use a
      range type compatible with the tree structure.
      55690705
    • Carsten Gräser's avatar
      Switch default node-to-range-map to HierarchicNodeToRangeMap · 7a17f787
      Carsten Gräser authored
      This is a non-compatible interface change. If you used a range
      on a nontrivial (depth>1) tree, this will not work as before,
      because the range entries are lo nonger accessed using a flat
      index. (But this is very unlikely.)
      
      As long as you only used power<...> or composite<...> in a non-nested
      way, the behaviour should still be the same.
      7a17f787
    • Carsten Gräser's avatar
      Implement HiererachicNodeToRangeMap · b2c0261f
      Carsten Gräser authored
      This simply forwards the tree path entries to the range
      assuming it's a nested container with compatible structure.
      b2c0261f
    • Carsten Gräser's avatar
      [bugfix] Fix resolveStaticMultiIndex · c10b9cd8
      Carsten Gräser authored
      Fix some small bugs.
      c10b9cd8
    • Carsten Gräser's avatar
      Pass treepath to node to range map · db863cea
      Carsten Gräser authored
      In general using the treepath is more natural here.
      While the node stores its treepath this is very likely
      to be removed soon, since in any place where you need
      the treepath it's available by other means (e.g. during
      tree traversal).
      
      Notice that this is an interface change! If you have
      implemented your own node-to-range map, you will have
      to add the additional parameter to operator().
      
      At a later stage one may also want to drop the node argument.
      However, it's not totally clear if this is needed in custom
      maps.
      db863cea
    • Carsten Gräser's avatar
    • Carsten Gräser's avatar
      Generalize multi-index access · 8c32874d
      Carsten Gräser authored
      Implement `resolveDynamicMultiIndex()` and `resolveStaticMultiIndex()`.
      While the latter simply chains `[i]` calls for all entries `i` of the
      multi-index the former has to be given a termination criterion.
      For the static version we require, that the containers operator[]
      suppors the multi-index entries directly. For a nested multi-type
      container, you can e.g. use a corresponding HybridTreePath as
      multi-index.
      
      In principle `resolveDynamicMultiIndex` superceeds
      `hybridIndexAccess()` but the interface is slightly different.
      However, `habridIndexAccess()` may be deprecated at a later stage.
      8c32874d
  6. 12 Jun, 2018 2 commits
    • Carsten Gräser's avatar
      Implement callableCheck() and negatePredicate() · 67f8abb7
      Carsten Gräser authored
      callableCheck(f) returns a function predicate that for
      cheching if f is callable using a given argument list.
      The following allows to check if f can be called with
      a and b as arguments. The result is returned as bool_constant.
      
      ```cpp
        auto fCallable = callableCheck(f);
        if (fCallable(a,b))
          ...
      ```
      
      negatePredicate(f) allows to negate a given predicate function.
      Similar to the above example checking if f is not callable
      with a and b can be done by:
      
      ```cpp
        auto fNotCallable = negatePredicate(callableCheck(f));
        if (fNotCallable(a,b))
          ...
      ```
      
      This can be viewed as a runtime/inline version of std::is_detected
      and std::negate. While the latter work on types and require to encode
      expressions as meta functions (type-aliases), the functions provided
      here work on values and allow to encode expressions in functions. This
      has the advantage that is allows to write simple, self-contained scopes
      at block-level.
      67f8abb7
    • Carsten Gräser's avatar
      [concept] Cleanup isCallable() · bd99d7c9
      Carsten Gräser authored
      Now isCallable(f,args...) checks if f(args...) is valid. Before,
      the arguments had to be given as a Dune::TypeList which is misleading
      and can even be considered a bug. Since this was not used anywhere,
      this commit changes the behaviour to the expected one.
      
      This also fixes the retun value type of isCallable() by
      properly forwarding bool_constant values.
      bd99d7c9
  7. 07 Jun, 2018 2 commits
  8. 05 Jun, 2018 2 commits
    • Carsten Gräser's avatar
      [bugfix] Fix makebasistest.cc · 8e41b98c
      Carsten Gräser authored
      This was missing a header which was implicitly
      included when the MR was created. Now we can simply
      drop the VectorBackend, because interpolate will
      create and use an ISTLVectorBackend automatically.
      8e41b98c
    • Steffen Müthing's avatar
      Fix typo · 45641f6e
      Steffen Müthing authored
      45641f6e
  9. 03 Jun, 2018 3 commits
  10. 04 May, 2018 2 commits
    • Carsten Gräser's avatar
      [bugfix] Use PowerPreBasis::MultiIndex::max_size as size for SizePrefix · fb41c3f4
      Carsten Gräser authored
      The SubPreBasis::SizePrefix::max_size may be to small,
      if the current PowerPreBasis addds a digit. The solution
      if to use PowerPreBasis::MultiIndex::max_size. This may
      be suboptimal if this PowerPreBasis is an inner node
      and more digits are added later. Before trying to optimaze this,
      one should benchmark which solution is better:
      * Use an optimal (as small as possible) SizePrefix
        in each node.
      * Use the same SizePrefix for all nodes to allow
        modification insteaf of copying.
      fb41c3f4
    • Carsten Gräser's avatar
      Add element() method to inner nodes · 62375c45
      Carsten Gräser authored
      There's no reason to not have the element method for inner
      nodes. Computing the element ic cheap here anyway, because
      this can be forwarded to the children (which themselves
      forward this to the LocalView that stores the actual
      element copy).
      62375c45