Introduce more general "applyEntrywise"

There is no need to restrict oneself to binary operators.

dune/matrix-vector/concepts.hh

@@ -30,14 +30,14 @@ struct HasSize {
   auto require(C&& c) -> decltype(c.size());
 };
 
-struct IsLegalBinaryOperator {
-  template <class C, class D, class Op>
-  auto require(C&& c, D&& d, Op&& op) -> decltype(op(c,d));
+struct CanBeApplied {
+  template <class C, class Op, class... D>
+  auto require(C&& c, Op&& op, D&&... d) -> decltype(c=op(d...));
 };
 
-template <class C, class D, class Op>
-constexpr bool isLegalBinaryOperator(C&& c, D&& d, Op&& op) {
-  return models<IsLegalBinaryOperator, C, D, Op>();
+template <class C, class Op, class... D>
+constexpr auto canBeApplied(C&& c, Op&& op, D&&... d) {
+  return models<CanBeApplied, C, Op, D...>();
 }
 
 } // end namespace Concept

dune/matrix-vector/genericvectortools.hh

@@ -45,20 +45,21 @@ void truncate(Vector& v, const BitVector& tr) {
   Impl::ScalarSwitch<Vector>::truncate(v, tr);
 }
 
-/**! For a given operator "op", compute x = op(x,y) ENTRYWISE.
+
+/**! For a given operator "op", compute x = op(y...) ENTRYWISE.
  *
  * If the op is not defined for the given types,
  * the operator is recursively applied to subblocks
  * until it can be used.
  */
-template<typename X, typename Y, typename BinaryOp>
-void inplaceBinary(X&&  x, Y&& y, BinaryOp&& op) {
-  if constexpr(Concept::isLegalBinaryOperator(x,y,op)) {
-    x = op(x,y);
+template<typename X, typename Op, typename... Y>
+void applyEntrywise(X&& x, Op&& op, Y&&... y) {
+  if constexpr(decltype(Concept::canBeApplied(x, op, y...))::value) {
+    x = op(y...);
   }
   else {
     for (std::size_t i = 0; i < x.size(); ++i) {
-      inplaceBinary(x[i], y[i], op);
+      applyEntrywise(x[i], op, y[i]...);
     }
   }
 }

dune/matrix-vector/test/genericvectortoolstest.cc

@@ -36,10 +36,11 @@ TestSuite test_inplace_or() {
   // xx and yy, because we explicitly check if the given input is
   // bool (or something convertible) and in that case apply
   // the operator
-  auto my_or = [](bool xx, bool yy) { return xx || yy; };
+  auto my_or = [](bool xx, bool yy) -> bool
+  { return xx || yy; };
 
   auto inplace_or = [&](auto& x, const auto& y) {
-    inplaceBinary(x,y, my_or);
+    applyEntrywise(x, my_or, x, y);
   };
 
   // check bools (trivial case)
@@ -108,13 +109,64 @@ TestSuite test_inplace_or() {
   return suite;
 }
 
+TestSuite test_plus() {
+  TestSuite suite;
+
+  using namespace Dune::MatrixVector::Generic;
+
+  // we mimic x = y+z
+  auto my_plus = std::plus<double>{};
+  auto inplace_plus = [&](auto& x, const auto& y, const auto& z) { applyEntrywise(x, my_plus, y, z); };
+
+  // test double
+  {
+    // both values should be exact in binary representation
+    auto x = 0;
+    auto y = 2.5;
+    auto z = 1.5;
+
+    inplace_plus(x, y, z); // x = y + z
+    suite.check(x== 4., "inplace_plus failed for double");
+  }
+
+  // test vector<double>
+  {
+    auto x = std::vector<double>(10);
+    auto y = std::vector<double>(10, 2.5);
+    auto z = std::vector<double>(10, 1.5);
+
+    inplace_plus(x, y, z); // x = y + z
+    for (const auto& entry : x)
+      suite.check(entry == 4.0, "inplace_plus failed for vector<double> entry.");
+  }
+
+  // test BlockVector<FieldVector<double, 2>>
+  {
+    auto x = BlockVector<FieldVector<double, 2>>(10);
+    auto y = BlockVector<FieldVector<double, 2>>(10);
+    auto z = BlockVector<FieldVector<double, 2>>(10);
+
+    y = 2.5;
+    z = 1.5;
+
+    inplace_plus(x, y, z); // x = y + z
+    for (const auto& block : x)
+      for (const auto& entry : block)
+        suite.check(entry == 4.0, "inplace_plus failed for BlockVector<FieldVector<2>> entry.");
+  }
+
+
+  return suite;
+}
+
 TestSuite test_inplace_plus() {
   TestSuite suite;
 
   using namespace Dune::MatrixVector::Generic;
 
+  // we mimic x+=y
   auto my_plus = std::plus<double>{};
-  auto inplace_plus = [&](auto& x, const auto& y) { inplaceBinary(x, y, my_plus); };
+  auto inplace_plus = [&](auto& x, const auto& y) { applyEntrywise(x, my_plus, x, y); };
 
   // test double
   {
@@ -153,12 +205,12 @@ TestSuite test_inplace_plus() {
 
   return suite;
 }
-TestSuite test_inplaceBinary() {
+TestSuite test_applyEntrywise() {
   TestSuite suite;
 
-  // we test two example operators, the || and the + operator.
   suite.subTest(test_inplace_or());
   suite.subTest(test_inplace_plus());
+  suite.subTest(test_plus());
   return suite;
 }
 
@@ -171,7 +223,7 @@ int main(int argc, char* argv[]) {
   // TODO: There are more things in genericvectortools
   // that need tests!
 
-  suite.subTest(test_inplaceBinary());
+  suite.subTest(test_applyEntrywise());
 
   return suite.exit();;
 }