diff --git a/include/rotgen/container/ref/fixed.hpp b/include/rotgen/container/ref/fixed.hpp
index 67a1268..b4974a0 100644
--- a/include/rotgen/container/ref/fixed.hpp
+++ b/include/rotgen/container/ref/fixed.hpp
@@ -143,7 +143,10 @@ namespace rotgen
 
     value_type _norm() const { return parent::norm(); }
 
-    value_type _lpNorm() const { return parent::lpNorm(); }
+    template<int P> value_type _lpNorm() const
+    {
+      return parent::template lpNorm<P>();
+    }
 
     value_type _squaredNorm() const { return parent::squaredNorm(); }
 
diff --git a/include/rotgen/functions/functions.hpp b/include/rotgen/functions/functions.hpp
index a7c0ab4..bb5c522 100644
--- a/include/rotgen/functions/functions.hpp
+++ b/include/rotgen/functions/functions.hpp
@@ -23,10 +23,7 @@ namespace rotgen
   {
     if constexpr (requires { m.rows(); }) { return m.rows(); }
     else if constexpr (requires { m._rows(); }) { return m._rows(); }
-    else
-    {
-      return detail::unsupported_parameters<decltype(m)>();
-    }
+    else { return detail::unsupported_parameters<decltype(m)>(); }
   }
 
   /// Returns the column count of a matrix.
@@ -35,30 +32,21 @@ namespace rotgen
 
     if constexpr (requires { m.cols(); }) { return m.cols(); }
     else if constexpr (requires { m._cols(); }) { return m._cols(); }
-    else
-    {
-      return detail::unsupported_parameters<decltype(m)>();
-    }
+    else { return detail::unsupported_parameters<decltype(m)>(); }
   }
 
   Index startRow(auto const& m)
   {
     if constexpr (requires { m.startRow(); }) { return m.startRow(); }
     else if constexpr (requires { m._startRow(); }) { return m._startRow(); }
-    else
-    {
-      return detail::unsupported_parameters<decltype(m)>();
-    }
+    else { return detail::unsupported_parameters<decltype(m)>(); }
   }
 
   Index startCol(auto const& m)
   {
     if constexpr (requires { m.startCol(); }) { return m.startCol(); }
     else if constexpr (requires { m._startCol(); }) { return m._startCol(); }
-    else
-    {
-      return detail::unsupported_parameters<decltype(m)>();
-    }
+    else { return detail::unsupported_parameters<decltype(m)>(); }
   }
 
   /// Returns the size of a matrix.
@@ -92,10 +80,7 @@ namespace rotgen
     {
       a._conservativeResize(s);
     }
-    else
-    {
-      return detail::unsupported_parameters<decltype(a)>();
-    }
+    else { return detail::unsupported_parameters<decltype(a)>(); }
   }
 
   void conservativeResize(auto& a, int r, int c)
@@ -108,10 +93,7 @@ namespace rotgen
     {
       a._conservativeResize(r, c);
     }
-    else
-    {
-      return detail::unsupported_parameters<decltype(a)>();
-    }
+    else { return detail::unsupported_parameters<decltype(a)>(); }
   }
 
   Index innerStride(auto const& m)
@@ -121,10 +103,7 @@ namespace rotgen
     {
       return m._innerStride();
     }
-    else
-    {
-      return detail::unsupported_parameters<decltype(m)>();
-    }
+    else { return detail::unsupported_parameters<decltype(m)>(); }
   }
 
   Index outerStride(auto const& m)
@@ -134,10 +113,7 @@ namespace rotgen
     {
       return m._outerStride();
     }
-    else
-    {
-      return detail::unsupported_parameters<decltype(m)>();
-    }
+    else { return detail::unsupported_parameters<decltype(m)>(); }
   }
 
   //----------------------------------------------------------------------------
@@ -151,20 +127,14 @@ namespace rotgen
     {
       return m._normalized();
     }
-    else
-    {
-      return detail::unsupported_parameters<decltype(m)>();
-    }
+    else { return detail::unsupported_parameters<decltype(m)>(); }
   }
 
   decltype(auto) transpose(auto const& m)
   {
     if constexpr (requires { m.transpose(); }) { return m.transpose(); }
     else if constexpr (requires { m._transpose(); }) { return m._transpose(); }
-    else
-    {
-      return detail::unsupported_parameters<decltype(m)>();
-    }
+    else { return detail::unsupported_parameters<decltype(m)>(); }
   }
 
   decltype(auto) conjugate(auto const& m)
@@ -177,49 +147,46 @@ namespace rotgen
   {
     if constexpr (requires { m.adjoint(); }) { return m.adjoint(); }
     else if constexpr (requires { m._adjoint(); }) { return m._adjoint(); }
-    else
-    {
-      return detail::unsupported_parameters<decltype(m)>();
-    }
+    else { return detail::unsupported_parameters<decltype(m)>(); }
   }
 
-  void normalize(auto& a)
+  template<typename C> void normalize(C&& a)
   {
-    if constexpr (requires { a.normalize(); }) { a.normalize(); }
-    else if constexpr (requires { a._normalize(); }) // PROCESSME
+    if constexpr (requires { std::forward<C>(a).normalize(); })
     {
-      a._normalize();
+      std::forward<C>(a).normalize();
     }
-    else
+    else if constexpr (requires { std::forward<C>(a)._normalize(); })
     {
-      return detail::unsupported_parameters<decltype(a)>();
+      std::forward<C>(a)._normalize();
     }
+    else { return detail::unsupported_parameters<decltype(a)>(); }
   }
 
-  void transposeInPlace(auto& a)
+  template<typename C> void transposeInPlace(C&& a)
   {
-    if constexpr (requires { a.transposeInPlace(); }) { a.transposeInPlace(); }
-    else if constexpr (requires { a._transposeInPlace(); }) // PROCESSME
+    if constexpr (requires { std::forward<C>(a).transposeInPlace(); })
     {
-      a._transposeInPlace();
+      std::forward<C>(a).transposeInPlace();
     }
-    else
+    else if constexpr (requires { std::forward<C>(a)._transposeInPlace(); })
     {
-      return detail::unsupported_parameters<decltype(a)>();
+      std::forward<C>(a)._transposeInPlace();
     }
+    else { return detail::unsupported_parameters<decltype(a)>(); }
   }
 
-  void adjointInPlace(auto& a)
+  template<typename C> void adjointInPlace(C&& a)
   {
-    if constexpr (requires { a.adjointInPlace(); }) { a.adjointInPlace(); }
-    else if constexpr (requires { a._adjointInPlace(); }) // PROCESSME
+    if constexpr (requires { std::forward<C>(a).adjointInPlace(); })
     {
-      a._adjointInPlace();
+      std::forward<C>(a).adjointInPlace();
     }
-    else
+    else if constexpr (requires { std::forward<C>(a)._adjointInPlace(); })
     {
-      return detail::unsupported_parameters<decltype(a)>();
+      std::forward<C>(a)._adjointInPlace();
     }
+    else { return detail::unsupported_parameters<decltype(a)>(); }
   }
 
   //----------------------------------------------------------------------------
@@ -233,10 +200,7 @@ namespace rotgen
     {
       return arg._cwiseAbs();
     }
-    else
-    {
-      return detail::unsupported_parameters<decltype(arg)>();
-    }
+    else { return detail::unsupported_parameters<decltype(arg)>(); }
   }
 
   auto abs2(auto const& arg)
@@ -246,10 +210,7 @@ namespace rotgen
     {
       return arg._cwiseAbs2();
     }
-    else
-    {
-      return detail::unsupported_parameters<decltype(arg)>();
-    }
+    else { return detail::unsupported_parameters<decltype(arg)>(); }
   }
 
   auto rec(auto const& arg)
@@ -262,10 +223,7 @@ namespace rotgen
     {
       return arg._cwiseInverse();
     }
-    else
-    {
-      return detail::unsupported_parameters<decltype(arg)>();
-    }
+    else { return detail::unsupported_parameters<decltype(arg)>(); }
   }
 
   auto sqrt(auto const& arg)
@@ -284,10 +242,7 @@ namespace rotgen
     {
       return min(generalize_t<A const>(a), generalize_t<B const>(b));
     }
-    else
-    {
-      return base_of(a).cwiseMin(base_of(b));
-    }
+    else { return base_of(a).cwiseMin(base_of(b)); }
   }
 
   template<concepts::entity A>
@@ -297,10 +252,7 @@ namespace rotgen
     {
       return min(generalize_t<A const>(a), b);
     }
-    else
-    {
-      return base_of(a).cwiseMin(b);
-    }
+    else { return base_of(a).cwiseMin(b); }
   }
 
   template<concepts::entity B>
@@ -310,10 +262,7 @@ namespace rotgen
     {
       return min(a, generalize_t<B const>(b));
     }
-    else
-    {
-      return base_of(b).cwiseMin(a);
-    }
+    else { return base_of(b).cwiseMin(a); }
   }
 
   template<concepts::entity A, concepts::entity B>
@@ -323,10 +272,7 @@ namespace rotgen
     {
       return max(generalize_t<A const>(a), generalize_t<B const>(b));
     }
-    else
-    {
-      return base_of(a).cwiseMax(base_of(b));
-    }
+    else { return base_of(a).cwiseMax(base_of(b)); }
   }
 
   template<concepts::entity A>
@@ -336,10 +282,7 @@ namespace rotgen
     {
       return max(generalize_t<A const>(a), b);
     }
-    else
-    {
-      return base_of(a).cwiseMax(b);
-    }
+    else { return base_of(a).cwiseMax(b); }
   }
 
   template<concepts::entity B>
@@ -349,10 +292,7 @@ namespace rotgen
     {
       return max(a, generalize_t<B const>(b));
     }
-    else
-    {
-      return base_of(b).cwiseMax(a);
-    }
+    else { return base_of(b).cwiseMax(a); }
   }
 
   template<concepts::entity A, concepts::entity B>
@@ -362,10 +302,7 @@ namespace rotgen
     {
       return mul(generalize_t<A const>(a), generalize_t<B const>(b));
     }
-    else
-    {
-      return base_of(a).cwiseProduct(base_of(b));
-    }
+    else { return base_of(a).cwiseProduct(base_of(b)); }
   }
 
   template<concepts::entity A>
@@ -387,10 +324,7 @@ namespace rotgen
     {
       return div(generalize_t<A const>(a), generalize_t<B const>(b));
     }
-    else
-    {
-      return base_of(a).array() / base_of(b).array();
-    }
+    else { return base_of(a).array() / base_of(b).array(); }
   }
 
   template<concepts::entity A>
@@ -412,10 +346,7 @@ namespace rotgen
   {
     if constexpr (requires { arg.trace(); }) { return arg.trace(); }
     else if constexpr (requires { arg._trace(); }) { return arg._trace(); }
-    else
-    {
-      return detail::unsupported_parameters<decltype(arg)>();
-    }
+    else { return detail::unsupported_parameters<decltype(arg)>(); }
   }
 
   auto squaredNorm(auto const& arg)
@@ -425,50 +356,36 @@ namespace rotgen
     {
       return arg._squaredNorm();
     }
-    else
-    {
-      return detail::unsupported_parameters<decltype(arg)>();
-    }
+    else { return detail::unsupported_parameters<decltype(arg)>(); }
   }
 
   auto norm(auto const& arg)
   {
     if constexpr (requires { arg.norm(); }) { return arg.norm(); }
     else if constexpr (requires { arg._norm(); }) { return arg._norm(); }
-    else
-    {
-      return detail::unsupported_parameters<decltype(arg)>();
-    }
+    else { return detail::unsupported_parameters<decltype(arg)>(); }
   }
 
   auto sum(auto const& arg)
+  requires(requires { arg.sum(); } || requires { arg._sum(); })
   {
     if constexpr (requires { arg.sum(); }) { return arg.sum(); }
     else if constexpr (requires { arg._sum(); }) { return arg._sum(); }
-    else
-    {
-      return detail::unsupported_parameters<decltype(arg)>();
-    }
+    else { return detail::unsupported_parameters<decltype(arg)>(); }
   }
 
   auto prod(auto const& arg)
   {
     if constexpr (requires { arg.prod(); }) { return arg.prod(); }
     else if constexpr (requires { arg._prod(); }) { return arg._prod(); }
-    else
-    {
-      return detail::unsupported_parameters<decltype(arg)>();
-    }
+    else { return detail::unsupported_parameters<decltype(arg)>(); }
   }
 
   auto mean(auto const& arg)
   {
     if constexpr (requires { arg.mean(); }) { return arg.mean(); }
     else if constexpr (requires { arg._mean(); }) { return arg._mean(); }
-    else
-    {
-      return detail::unsupported_parameters<decltype(arg)>();
-    }
+    else { return detail::unsupported_parameters<decltype(arg)>(); }
   }
 
   template<concepts::entity A, concepts::entity B>
@@ -480,10 +397,7 @@ namespace rotgen
     {
       return dot(generalize_t<A const>(a), generalize_t<B const>(b));
     }
-    else
-    {
-      return base_of(a).dot(base_of(b));
-    }
+    else { return base_of(a).dot(base_of(b)); }
   }
 
   auto maxCoeff(auto const& arg)
@@ -493,10 +407,7 @@ namespace rotgen
     {
       return arg._maxCoeff();
     }
-    else
-    {
-      return detail::unsupported_parameters<decltype(arg)>();
-    }
+    else { return detail::unsupported_parameters<decltype(arg)>(); }
   }
 
   auto minCoeff(auto const& arg)
@@ -506,10 +417,7 @@ namespace rotgen
     {
       return arg._minCoeff();
     }
-    else
-    {
-      return detail::unsupported_parameters<decltype(arg)>();
-    }
+    else { return detail::unsupported_parameters<decltype(arg)>(); }
   }
 
   template<std::integral IndexType>
@@ -523,10 +431,7 @@ namespace rotgen
     {
       return arg._maxCoeff(row, col);
     }
-    else
-    {
-      return detail::unsupported_parameters<decltype(arg)>();
-    }
+    else { return detail::unsupported_parameters<decltype(arg)>(); }
   }
 
   template<std::integral IndexType>
@@ -540,10 +445,7 @@ namespace rotgen
     {
       return arg._minCoeff(row, col);
     }
-    else
-    {
-      return detail::unsupported_parameters<decltype(arg)>();
-    }
+    else { return detail::unsupported_parameters<decltype(arg)>(); }
   }
 
   template<int P, typename T> auto lpNorm(T const& arg)
@@ -558,16 +460,12 @@ namespace rotgen
       static_assert(P == 1 || P == 2 || P == Infinity);
       return arg.template _lpNorm<P>();
     }
-    else
-    {
-      return detail::unsupported_parameters<decltype(arg)>();
-    }
+    else { return detail::unsupported_parameters<decltype(arg)>(); }
   }
 
   //----------------------------------------------------------------------------
   // Expression handling
   //----------------------------------------------------------------------------
-
   template<typename T> decltype(auto) noalias(T&& t)
   {
     if constexpr (requires { std::forward<T>(t).noalias(); })
@@ -578,10 +476,7 @@ namespace rotgen
     {
       return std::forward<T>(t)._noalias();
     }
-    else
-    {
-      return detail::unsupported_parameters<decltype(t)>();
-    }
+    else { return detail::unsupported_parameters<decltype(t)>(); }
   }
 
   template<typename T> auto evaluate(T&& t)
@@ -598,10 +493,7 @@ namespace rotgen
     {
       return std::forward<T>(t).eval();
     }
-    else
-    {
-      return detail::unsupported_parameters<decltype(t)>();
-    }
+    else { return detail::unsupported_parameters<decltype(t)>(); }
   }
 
   //----------------------------------------------------------------------------
@@ -609,17 +501,13 @@ namespace rotgen
   // TODO: Adapt other functions ot behave as inverse and limit code in
   // non-ref/non-map containers
   //----------------------------------------------------------------------------
-
   template<typename A> auto inverse(A const& a)
   {
     if constexpr (!use_expression_templates)
     {
       return inverse(generalize_t<A const>(a));
     }
-    else
-    {
-      return base_of(a).inverse();
-    }
+    else { return base_of(a).inverse(); }
   }
 
   template<concepts::vectorND<3> L, concepts::vectorND<3> R>
@@ -635,9 +523,6 @@ namespace rotgen
     {
       return base_of(l)._cross(base_of(r));
     }
-    else
-    {
-      return l._cross(r);
-    }
+    else { return l._cross(r); }
   }
 }