Feat/block implementation

See merge request oss/rotgen!10

include/rotgen/block.hpp

@@ -35,22 +35,24 @@ namespace rotgen
 
     block(parent const& base) : parent(base) {}
 
-/*
+    concrete_type transpose() const
-block transpose() const
     {
-  return block(static_cast<parent const&>(*this).transpose());
+      return concrete_type(static_cast<parent const &>(*this).transpose());
     }
 
-block conjugate() const
+    concrete_type conjugate() const
     {
-  return block(static_cast<parent const&>(*this).conjugate());
+      return concrete_type(static_cast<parent const &>(*this).conjugate());
     }
 
-block adjoint() const
+    concrete_type adjoint() const
     {
-  return block(static_cast<parent const&>(*this).adjoint());
+      return concrete_type(static_cast<parent const &>(*this).adjoint());
     }
-*/
+
+    void transposeInPlace() { parent::transposeInPlace(); }
+
+    void adjointInPlace()   { parent::adjointInPlace();   }
 
     friend bool operator==(block const& lhs, block const& rhs)
     {
@@ -74,6 +76,31 @@ block adjoint() const
       return concrete_type(static_cast<parent const&>(*this).operator-());
     }
 
+    concrete_type matrix_addition(block const& rhs) const
+    {
+      return concrete_type(static_cast<parent const&>(*this).matrix_addition(rhs));
+    }
+
+    concrete_type matrix_subtraction(block const& rhs) const
+    {
+      return concrete_type(static_cast<parent const&>(*this).matrix_subtraction(rhs));
+    }
+
+    concrete_type matrix_multiplication(block const& rhs) const
+    {
+      return concrete_type(static_cast<parent const&>(*this).matrix_multiplication(rhs));
+    }
+
+    concrete_type matrix_multiplication(scalar_type rhs) const
+    {
+      return concrete_type(static_cast<parent const&>(*this).matrix_multiplication(rhs));
+    }
+
+    concrete_type matrix_division(scalar_type rhs) const
+    {
+      return concrete_type(static_cast<parent const&>(*this).matrix_division(rhs));
+    }
+
     block& operator*=(block const& rhs)
     {
       static_cast<parent&>(*this) *= static_cast<parent const&>(rhs);
@@ -152,46 +179,39 @@ block adjoint() const
     }
   };
 
-/*
+  template<typename Ref, int R, int C, bool I, int F>
-template<typename S, int R, int C, int O, int MR, int MC>
+  typename block<Ref, R, C, I, F>::concrete_type operator+(block<Ref, R, C, I, F> const& lhs, block<Ref, R, C, I, F> const& rhs)
-block<S,R,C,O,MR,MC> operator+(block<S,R,C,O,MR,MC> const& lhs, block<S,R,C,O,MR,MC> const& rhs)
   {
-  block<S,R,C,O,MR,MC> that(lhs);
+    return lhs.matrix_addition(rhs);
-  return that += rhs;
   }
 
-template<typename S, int R, int C, int O, int MR, int MC>
+  template<typename Ref, int R, int C, bool I, int F>
-block<S,R,C,O,MR,MC> operator-(block<S,R,C,O,MR,MC> const& lhs, block<S,R,C,O,MR,MC> const& rhs)
+  typename block<Ref, R, C, I, F>::concrete_type operator-(block<Ref, R, C, I, F> const& lhs, block<Ref, R, C, I, F> const& rhs)
   {
-  block<S,R,C,O,MR,MC> that(lhs);
+    return lhs.matrix_subtraction(rhs);
-  return that -= rhs;
   }
 
-template<typename S, int R, int C, int O, int MR, int MC>
+  template<typename Ref, int R, int C, bool I, int F>
-block<S,R,C,O,MR,MC> operator*(block<S,R,C,O,MR,MC> const& lhs, block<S,R,C,O,MR,MC> const& rhs)
+  typename block<Ref, R, C, I, F>::concrete_type operator*(block<Ref, R, C, I, F> const& lhs, block<Ref, R, C, I, F> const& rhs)
   {
-  block<S,R,C,O,MR,MC> that(lhs);
+    return lhs.matrix_multiplication(rhs);
-    return that *= rhs;
   }
 
-  template<typename S, int R, int C, int O, int MR, int MC>
+  template<typename Ref, int R, int C, bool I, int F>
-  block<S,R,C,O,MR,MC> operator*(block<S,R,C,O,MR,MC> const& lhs, double rhs)
+  typename block<Ref, R, C, I, F>::concrete_type operator*(block<Ref, R, C, I, F> const& lhs, double rhs)
   {
-    block<S,R,C,O,MR,MC> that(lhs);
+    return lhs.matrix_multiplication(rhs);
-    return that *= rhs;
   }
 
-  template<typename S, int R, int C, int O, int MR, int MC>
+  template<typename Ref, int R, int C, bool I, int F>
-  block<S,R,C,O,MR,MC> operator*(double lhs, block<S,R,C,O,MR,MC> const&  rhs)
+  typename block<Ref, R, C, I, F>::concrete_type operator*(double lhs, block<Ref, R, C, I, F> const& rhs)
   {
-    return rhs * lhs;
+    return rhs.matrix_multiplication(lhs);
   }
 
-  template<typename S, int R, int C, int O, int MR, int MC>
+  template<typename Ref, int R, int C, bool I, int F>
-  block<S,R,C,O,MR,MC> operator/(block<S,R,C,O,MR,MC> const& lhs, double rhs)
+  typename block<Ref, R, C, I, F>::concrete_type operator/(block<Ref, R, C, I, F> const& lhs, double rhs)
   {
-    block<S,R,C,O,MR,MC> that(lhs);
+    return lhs.matrix_division(rhs);
-    return that /= rhs;
   }
-*/
 }

include/rotgen/impl/block_model.hpp

@@ -28,12 +28,12 @@ class CLASSNAME
   std::size_t cols() const;
   std::size_t size() const;
 
-  // CLASSNAME transpose() const;
+  SOURCENAME transpose() const;
-  // CLASSNAME conjugate() const;
+  SOURCENAME conjugate() const;
-  // CLASSNAME adjoint() const;
+  SOURCENAME adjoint() const;
 
-  // void transposeInPlace();
+  void transposeInPlace();
-  // void adjointInPlace();
+  void adjointInPlace();
 
   TYPE sum()      const;
   TYPE prod()     const;
@@ -61,6 +61,12 @@ class CLASSNAME
   CLASSNAME& operator*=(TYPE  d);
   CLASSNAME& operator/=(TYPE  d);
 
+  SOURCENAME matrix_addition(CLASSNAME const& rhs) const;
+  SOURCENAME matrix_subtraction(CLASSNAME const& rhs) const;
+  SOURCENAME matrix_multiplication(CLASSNAME const& rhs) const;
+  SOURCENAME matrix_multiplication(TYPE s) const;
+  SOURCENAME matrix_division(TYPE s) const;
+
   friend std::ostream& operator<<(std::ostream&,CLASSNAME const&);
   friend bool operator==(CLASSNAME const& lhs, CLASSNAME const& rhs);
 

include/rotgen/impl/payload.hpp

@@ -27,6 +27,8 @@ namespace rotgen
     payload(data_type&& matrix) : data(std::move(matrix)) {}
 
     void assign(Eigen::Block<data_type> ref) { data = ref; }
+    void assign(data_type const& mat) { data = mat; }
+    void assign(data_type&& mat) { data = std::move(mat); }
   };
 
   struct matrix_impl64_row::payload
@@ -39,6 +41,8 @@ namespace rotgen
     payload(data_type&& matrix) : data(std::move(matrix)) {}
 
     void assign(Eigen::Block<data_type> ref) { data = ref; }
+    void assign(data_type const& mat) { data = mat; }
+    void assign(data_type&& mat) { data = std::move(mat); }
   };
 
   struct matrix_impl32_col::payload
@@ -51,6 +55,8 @@ namespace rotgen
     payload(data_type&& matrix) : data(std::move(matrix)) {}
 
     void assign(Eigen::Block<data_type> ref) { data = ref; }
+    void assign(data_type const& mat) { data = mat; }
+    void assign(data_type&& mat) { data = std::move(mat); }
   };
 
   struct matrix_impl32_row::payload
@@ -63,5 +69,7 @@ namespace rotgen
     payload(data_type&& matrix) : data(std::move(matrix)) {}
 
     void assign(Eigen::Block<data_type> ref) { data = ref; }
+    void assign(data_type const& mat) { data = mat; }
+    void assign(data_type&& mat) { data = std::move(mat); }
   };
 }

src/block_model.cpp

@@ -21,6 +21,7 @@ struct CLASSNAME::payload
   using data_type = Eigen::Block<base_type>;
 
   data_type data;
+
   payload (data_type const& o) : data(o) {}
 
   payload (base_type& r, std::size_t i0, std::size_t j0, std::size_t ni, std::size_t nj)
@@ -66,26 +67,22 @@ TYPE const& CLASSNAME::operator()(std::size_t index) const { return storage_->da
 
   const TYPE* CLASSNAME::data() const { return storage_->data.data(); }
 
-/*
+  SOURCENAME CLASSNAME::transpose() const
-CLASSNAME CLASSNAME::transpose() const
   {
-  CLASSNAME result(*this);
+    SOURCENAME result;
-  result.storage_->data.transposeInPlace();
+    result.storage()->assign(storage_->data.transpose().eval());
-  return result;
-
-}
-
-CLASSNAME CLASSNAME::conjugate() const
-{
-  CLASSNAME result(*this);
-  result.storage_->data = storage_->data.conjugate();
     return result;
   }
 
-CLASSNAME CLASSNAME::adjoint() const
+  SOURCENAME CLASSNAME::conjugate() const {
-{
+    SOURCENAME result;
-  CLASSNAME result(*this);
+    result.storage()->assign(storage_->data.conjugate().eval());
-  result.storage_->data.adjointInPlace();
+    return result;
+  }
+
+  SOURCENAME CLASSNAME::adjoint() const {
+    SOURCENAME result;
+    result.storage()->assign(storage_->data.adjoint().eval());
     return result;
   }
 
@@ -98,7 +95,6 @@ void CLASSNAME::adjointInPlace()
   {
     storage_->data.adjointInPlace();
   }
-*/
 
   TYPE CLASSNAME::sum()    const { return storage_->data.sum(); }
   TYPE CLASSNAME::prod()   const { return storage_->data.prod(); }
@@ -170,3 +166,38 @@ CLASSNAME& CLASSNAME::operator/=(TYPE s)
     storage_->data /= s;
     return *this;
   }
+
+  SOURCENAME CLASSNAME::matrix_addition(CLASSNAME const& rhs) const
+  {
+    SOURCENAME result;
+    result.storage()->assign(storage_->data + rhs.storage_->data);
+    return result;
+  }
+
+  SOURCENAME CLASSNAME::matrix_subtraction(CLASSNAME const& rhs) const
+  {
+    SOURCENAME result;
+    result.storage()->assign(storage_->data - rhs.storage_->data);
+    return result;
+  }
+
+  SOURCENAME CLASSNAME::matrix_multiplication(CLASSNAME const& rhs) const
+  {
+    SOURCENAME result;
+    result.storage()->assign(storage_->data * rhs.storage_->data);
+    return result;
+  }
+
+  SOURCENAME CLASSNAME::matrix_multiplication(TYPE s) const
+  {
+    SOURCENAME result;
+    result.storage()->assign(storage_->data * s);
+    return result;
+  }
+
+  SOURCENAME CLASSNAME::matrix_division(TYPE s) const
+  {
+    SOURCENAME result;
+    result.storage()->assign(storage_->data / s);
+    return result;
+  }

test/unit/block/arithmetic_functions.cpp

@@ -11,6 +11,37 @@
 #include <rotgen/extract.hpp>
 #include <Eigen/Dense>
 
+template<typename Type1, typename Type2>
+void test_comparison(const Type1& t1, const Type2& t2)
+{
+  TTS_EQUAL(static_cast<std::ptrdiff_t>(t1.rows()), static_cast<std::ptrdiff_t>(t2.rows()));
+  TTS_EQUAL(static_cast<std::ptrdiff_t>(t1.cols()), static_cast<std::ptrdiff_t>(t2.cols()));
+  for (std::size_t r = 0; r < static_cast<std::size_t>(t1.rows()); ++r)
+    for (std::size_t c = 0; c < static_cast<std::size_t>(t1.cols()); ++c)
+      TTS_EQUAL(t1(r, c), t2(r, c));
+}
+
+template<typename Matrix1, typename Matrix2, typename Block1, typename Block2>
+void test_block_unary_ops(const Matrix1& original_matrix, const Matrix2& ref_matrix,
+                        Block1 original_block, Block2 ref_block)
+{
+  test_comparison(original_block.transpose(), ref_block.transpose());
+  test_comparison(original_block.conjugate(), ref_block.conjugate());
+  test_comparison(original_block.adjoint(), ref_block.adjoint());
+
+  if (original_block.rows() == original_block.cols()) {
+    original_block.transposeInPlace();
+    ref_block.transposeInPlace();
+    test_comparison(original_block, ref_block);
+    test_comparison(original_matrix, ref_matrix);
+
+    original_block.adjointInPlace();
+    ref_block.adjointInPlace();
+    test_comparison(original_block, ref_block);
+    test_comparison(original_matrix, ref_matrix);
+  }
+}
+
 template<typename Block1, typename Block2>
 void compare_reductions(const Block1& block, const Block2& ref)
 {
@@ -68,8 +99,11 @@ void test_dynamic_block_reductions(rotgen::tests::matrix_block_test_case<MatrixT
         ref.bottomRows(matrix_construct.ni) },
   };
 
-  for (const auto& [original_block, ref_block] : test_cases)
+  for (const auto& [original_block, ref_block] : test_cases) {
     compare_reductions(original_block, ref_block);
+    test_block_unary_ops(original, ref, original_block, ref_block);
+  }
+
 }
 
 TTS_CASE_TPL("Test dynamic block reductions", rotgen::tests::types)
@@ -79,19 +113,19 @@ TTS_CASE_TPL("Test dynamic block reductions", rotgen::tests::types)
 
   std::vector<rotgen::tests::matrix_block_test_case<mat_t>> test_cases =
     {
-        {6, 5, [](auto r, auto c) {return r + c; }, 1, 2, 3, 2},
+        {6, 5, [](auto r, auto c) { return T(r + c); }, 1, 2, 3, 2},
-        {9, 11, [](auto r, auto c) {return r + c; }, 0, 1, 4, 9},
+        {9, 11, [](auto r, auto c) {return T(r + c); }, 0, 1, 4, 9},
-        {3, 3, [](auto  , auto  ) {return 0.0; }, 1, 1, 1, 1},
+        {3, 3, [](auto  , auto  ) {return T(0.0); }, 1, 1, 1, 1},
-        {1, 4, [](auto r, auto c) {return -r -c*c - 1234; }, 0, 0, 1, 1},
+        {1, 4, [](auto r, auto c) {return T(-r -c*c - 1234); }, 0, 0, 1, 1},
-        {4, 1, [](auto  , auto  ) {return 7.0; }, 2, 0, 2, 1},
+        {9, 9, [](auto r, auto c) {return T(-r + 2*c); }, 0, 1, 3, 3},
-        {1, 1, [](auto  , auto  ) {return 42.0; }, 0, 0, 1, 1},
+        {11, 13, [](auto r, auto c) {return T(std::tan(r+c)); }, 1, 1, 2, 2},
-        {12, 13, [](auto r, auto c) {return std::sin(r + c); }, 2, 3, 4, 5 },
+        {4, 1, [](auto  , auto  ) {return T(7.0); }, 2, 0, 2, 1},
-        {4, 9, [](auto r, auto c) {return -1.5 * r + 2.56 * c; }, 0, 1, 2, 3 },
+        {1, 1, [](auto  , auto  ) {return T(42.0); }, 0, 0, 1, 1},
-        {2, 5, [](auto r, auto c) {return (r == c ? 1.0 : 0.0); }, 1, 1, 1, 1},
+        {12, 13, [](auto r, auto c) {return T(std::sin(r + c)); }, 2, 3, 4, 5 },
+        {4, 9, [](auto r, auto c) {return T(-1.5 * r + 2.56 * c); }, 0, 1, 2, 3 },
+        {2, 5, [](auto r, auto c) {return T(r == c ? 1.0 : 0.0); }, 1, 1, 1, 1},
     };
 
   for (const auto& test_case : test_cases)
       test_dynamic_block_reductions<mat_t, T>(test_case);
-
-
 };

test/unit/block/operators.cpp

@@ -12,7 +12,7 @@
 
 template <typename MatrixType, typename T>
 void test_block_matrix_operations(rotgen::tests::matrix_block_test_case<MatrixType> const& matrix_construct,
-                                  auto b_init_fn, auto self_ops)
+                                  auto b_init_fn, auto ops, auto self_ops)
 {
   using EigenMatrix = Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>;
 
@@ -39,12 +39,12 @@ void test_block_matrix_operations(rotgen::tests::matrix_block_test_case<MatrixTy
   auto ref_b_block = ref_b.block(matrix_construct.i0, matrix_construct.j0,
                                    matrix_construct.ni, matrix_construct.nj);
 
-  /*auto result_block = ops(a_block, b_block);
+  auto result_block = ops(a_block, b_block);
   auto ref_result_block = ops(ref_a_block, ref_b_block);
 
   for (std::size_t r = 0; r < matrix_construct.ni; ++r)
     for (std::size_t c = 0; c < matrix_construct.nj; ++c)
-      TTS_EQUAL(result_block(r, c), ref_result_block(r, c));*/
+      TTS_EQUAL(result_block(r, c), ref_result_block(r, c));
 
   self_ops(a_block,b_block);
   self_ops(ref_a_block, ref_b_block);
@@ -65,7 +65,7 @@ void test_block_matrix_operations(rotgen::tests::matrix_block_test_case<MatrixTy
 
 template <typename MatrixType, typename T>
 void test_block_scalar_operations(rotgen::tests::matrix_block_test_case<MatrixType> const& matrix_construct,
-                            auto scalar, auto self_ops)
+                            auto scalar, auto ops, auto self_ops)
 {
   using EigenMatrix = Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>;
 
@@ -81,7 +81,12 @@ void test_block_scalar_operations(rotgen::tests::matrix_block_test_case<MatrixTy
   auto ref_a_block = ref_a.block(matrix_construct.i0, matrix_construct.j0,
                                matrix_construct.ni, matrix_construct.nj);
 
-  //TTS_EQUAL(ops(a, s), ref);
+  auto result = ops(a_block, scalar);
+  auto ref_result = ops(ref_a_block, scalar);
+
+  for (std::size_t r = 0; r < matrix_construct.ni; ++r)
+    for (std::size_t c = 0; c < matrix_construct.nj; ++c)
+      TTS_EQUAL(result(r, c), ref_result(r, c));
 
   self_ops(a_block,scalar);
   self_ops(ref_a_block, scalar);
@@ -113,8 +118,19 @@ void test_scalar_block_multiplications(rotgen::tests::matrix_block_test_case<Mat
   auto ref_a_block = ref_a.block(matrix_construct.i0, matrix_construct.j0,
                                matrix_construct.ni, matrix_construct.nj);
 
-  //TTS_EQUAL(a * s, ref);
+  auto a_scalar_multiplication = a_block * scalar;
-  //TTS_EQUAL(s * a, ref);
+  auto scalar_a_multiplication = scalar * a_block;
+  auto a_scalar_multiplication_ref = ref_a_block * scalar;
+  auto scalar_a_multiplication_ref = scalar * ref_a_block;
+
+  for (std::size_t r = 0; r < matrix_construct.ni; ++r)
+  {
+    for (std::size_t c = 0; c < matrix_construct.nj; ++c)
+    {
+      TTS_EQUAL(a_scalar_multiplication (r, c), a_scalar_multiplication_ref(r, c));
+      TTS_EQUAL(scalar_a_multiplication(r, c), scalar_a_multiplication_ref(r, c));
+    }
+  }
 
   a_block *= scalar;
   ref_a_block *= scalar;
@@ -157,7 +173,13 @@ void test_block_multiplication(rotgen::tests::matrix_block_test_case<MatrixType>
   auto ref_b_block = ref_b.block(b_matrix_construct.i0, b_matrix_construct.j0,
                                b_matrix_construct.ni, b_matrix_construct.nj);
 
-  // a * b
+  auto a_b_product_original = a_block * b_block;
+  auto a_b_product_ref = ref_a_block * ref_b_block;
+
+  for (std::size_t r = 0; r < a_matrix_construct.ni; ++r)
+    for (std::size_t c = 0; c < a_matrix_construct.nj; ++c)
+      TTS_EQUAL(a_b_product_original (r, c), a_b_product_ref(r, c));
+
   a_block *= b_block;
   ref_a_block *= ref_b_block;
 
@@ -183,19 +205,18 @@ TTS_CASE_TPL("Check block addition", rotgen::tests::types)
 <typename T, typename O>( tts::type< tts::types<T,O>> )
 {
   using mat_t = rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value>;
-  //auto op     = [](auto  a, auto b) { return a + b;   };
+  auto op     = [](auto  a, auto b) { return a + b;   };
   auto s_op   = [](auto& a, auto b) { return a += b;  };
 
-  //test_block_matrix_operations<mat_t, T>({1 , 1, init_a, 0, 0, 1, 1}, init_b, op, s_op);
+  test_block_matrix_operations<mat_t, T>({1 , 1, init_a, 0, 0, 1, 1}, init_b, op, s_op);
-  test_block_matrix_operations<mat_t, T>({1 , 1, init_a, 0, 0, 1, 1}, init_b, s_op);
+  test_block_matrix_operations<mat_t, T>({13 , 15, init_a, 1, 2, 3, 4}, init_b, op, s_op);
-  test_block_matrix_operations<mat_t, T>({13 , 15, init_a, 1, 2, 3, 4}, init_b, s_op);
+  test_block_matrix_operations<mat_t, T>({5 , 9, init_a, 2, 2, 2, 2}, init_b, op, s_op);
-  test_block_matrix_operations<mat_t, T>({5 , 9, init_a, 2, 2, 2, 2}, init_b, s_op);
+  test_block_matrix_operations<mat_t, T>({15 , 15, init_a, 3, 4, 5, 5}, init_b, op, s_op);
-  test_block_matrix_operations<mat_t, T>({15 , 15, init_a, 3, 4, 5, 5}, init_b, s_op);
+  test_block_matrix_operations<mat_t, T>({5 , 5, init_b, 1, 0, 3, 2}, init_a, op, s_op);
-  test_block_matrix_operations<mat_t, T>({5 , 5, init_b, 1, 0, 3, 2}, init_a, s_op);
+  test_block_matrix_operations<mat_t, T>({10, 1, init_a, 0, 0, 5, 1}, init_b, op, s_op);
-  test_block_matrix_operations<mat_t, T>({10, 1, init_a, 0, 0, 5, 1}, init_b, s_op);
+  test_block_matrix_operations<mat_t, T>({1 , 10, init_a, 0, 0, 1, 5}, init_b, op, s_op);
-  test_block_matrix_operations<mat_t, T>({1 , 10, init_a, 0, 0, 1, 5}, init_b, s_op);
+  test_block_matrix_operations<mat_t, T>({21 , 5, init_0, 4, 4, 10, 1}, init_b, op, s_op);
-  test_block_matrix_operations<mat_t, T>({21 , 5, init_0, 4, 4, 10, 1}, init_b, s_op);
+  test_block_matrix_operations<mat_t, T>({11 , 7, init_a, 2, 0, 7, 5}, init_0, op, s_op);
-  test_block_matrix_operations<mat_t, T>({11 , 7, init_a, 2, 0, 7, 5}, init_0, s_op);
 };
 
 
@@ -203,19 +224,19 @@ TTS_CASE_TPL("Check block subtraction", rotgen::tests::types)
 <typename T, typename O>( tts::type< tts::types<T,O>> )
 {
   using mat_t = rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value>;
-  //auto op     = [](auto  a, auto b) { return a - b;   };
+  auto op     = [](auto  a, auto b) { return a - b;   };
   auto s_op   = [](auto& a, auto b) { return a -= b;  };
 
-  //test_block_matrix_operations<mat_t, T>({1 , 1, init_a, 0, 0, 1, 1}, init_b, op, s_op);
+  test_block_matrix_operations<mat_t, T>({1 , 1, init_a, 0, 0, 1, 1}, init_b, op, s_op);
-  test_block_matrix_operations<mat_t, T>({1 , 1, init_a, 0, 0, 1, 1}, init_b, s_op);
+  test_block_matrix_operations<mat_t, T>({1 , 1, init_a, 0, 0, 1, 1}, init_b, op, s_op);
-  test_block_matrix_operations<mat_t, T>({13 , 15, init_a, 1, 2, 3, 4}, init_b, s_op);
+  test_block_matrix_operations<mat_t, T>({13 , 15, init_a, 1, 2, 3, 4}, init_b, op, s_op);
-  test_block_matrix_operations<mat_t, T>({5 , 9, init_a, 2, 2, 2, 2}, init_b, s_op);
+  test_block_matrix_operations<mat_t, T>({5 , 9, init_a, 2, 2, 2, 2}, init_b, op, s_op);
-  test_block_matrix_operations<mat_t, T>({15 , 15, init_a, 3, 4, 5, 5}, init_b, s_op);
+  test_block_matrix_operations<mat_t, T>({15 , 15, init_a, 3, 4, 5, 5}, init_b, op, s_op);
-  test_block_matrix_operations<mat_t, T>({5 , 5, init_b, 1, 0, 3, 2}, init_a, s_op);
+  test_block_matrix_operations<mat_t, T>({5 , 5, init_b, 1, 0, 3, 2}, init_a, op, s_op);
-  test_block_matrix_operations<mat_t, T>({10, 1, init_a, 0, 0, 5, 1}, init_b, s_op);
+  test_block_matrix_operations<mat_t, T>({10, 1, init_a, 0, 0, 5, 1}, init_b, op, s_op);
-  test_block_matrix_operations<mat_t, T>({1 , 10, init_a, 0, 0, 1, 5}, init_b,s_op);
+  test_block_matrix_operations<mat_t, T>({1 , 10, init_a, 0, 0, 1, 5}, init_b,op, s_op);
-  test_block_matrix_operations<mat_t, T>({21 , 5, init_0, 4, 4, 10, 1}, init_b, s_op);
+  test_block_matrix_operations<mat_t, T>({21 , 5, init_0, 4, 4, 10, 1}, init_b, op, s_op);
-  test_block_matrix_operations<mat_t, T>({11 , 7, init_a, 2, 0, 7, 5}, init_0, s_op);
+  test_block_matrix_operations<mat_t, T>({11 , 7, init_a, 2, 0, 7, 5}, init_0, op, s_op);
 };
 
 
@@ -258,17 +279,16 @@ TTS_CASE_TPL("Check block division with scalar", rotgen::tests::types)
 <typename T, typename O>( tts::type< tts::types<T,O>> )
 {
   using mat_t = rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value>;
-  //auto op     = [](auto  a, auto b) { return a / b;   };
+  auto op     = [](auto  a, auto b) { return a / b;   };
   auto s_op   = [](auto& a, auto b) { return a /= b;  };
 
-  //test_block_scalar_operations<mat_t, T>({1 , 1, init_a, 0, 0, 1, 1}, T{ 3.5}, op, s_op);
+  test_block_scalar_operations<mat_t, T>({1 , 1, init_a, 0, 0, 1, 1}, T{ 3.5}, op, s_op);
-  test_block_scalar_operations<mat_t, T>({1 , 1, init_a, 0, 0, 1, 1}, T{ 3.5}, s_op);
+  test_block_scalar_operations<mat_t, T>({13 , 15, init_a, 1, 2, 3, 4}, T{-2.5}, op, s_op);
-  test_block_scalar_operations<mat_t, T>({13 , 15, init_a, 1, 2, 3, 4}, T{-2.5}, s_op);
+  test_block_scalar_operations<mat_t, T>({5 , 9, init_a, 2, 2, 2, 2}, T{ 42. }, op, s_op);
-  test_block_scalar_operations<mat_t, T>({5 , 9, init_a, 2, 2, 2, 2}, T{ 42. }, s_op);
+  test_block_scalar_operations<mat_t, T>({15 , 15, init_a, 3, 4, 5, 5}, T{-5. }, op, s_op);
-  test_block_scalar_operations<mat_t, T>({15 , 15, init_a, 3, 4, 5, 5}, T{-5. }, s_op);
+  test_block_scalar_operations<mat_t, T>({5 , 5, init_b, 1, 0, 3, 2}, T{ 1. }, op, s_op);
-  test_block_scalar_operations<mat_t, T>({5 , 5, init_b, 1, 0, 3, 2}, T{ 1. }, s_op);
+  test_block_scalar_operations<mat_t, T>({10, 1, init_a, 0, 0, 5, 1}, T{ 0. }, op, s_op);
-  test_block_scalar_operations<mat_t, T>({10, 1, init_a, 0, 0, 5, 1}, T{ 0. }, s_op);
+  test_block_scalar_operations<mat_t, T>({1 , 10, init_a, 0, 0, 1, 5}, T{ 6. }, op, s_op);
-  test_block_scalar_operations<mat_t, T>({1 , 10, init_a, 0, 0, 1, 5}, T{ 6. },s_op);
+  test_block_scalar_operations<mat_t, T>({21 , 5, init_0, 4, 4, 10, 1}, T{ 10.}, op, s_op);
-  test_block_scalar_operations<mat_t, T>({21 , 5, init_0, 4, 4, 10, 1}, T{ 10.}, s_op);
+  test_block_scalar_operations<mat_t, T>({11 , 7, init_a, 2, 0, 7, 5}, T{-0.5}, op, s_op);
-  test_block_scalar_operations<mat_t, T>({11 , 7, init_a, 2, 0, 7, 5}, T{-0.5}, s_op);
 };