Added function field_operation2()

src/Diff.cc

@@ -27,6 +27,30 @@
 #include "field_functions.h"
 #include "pmlist.h"
 
+// clang-format off
+template <typename FUNC, typename FIELD, typename... ARGS>
+inline auto
+field_operation(FUNC func, FIELD &field, ARGS &...args)
+-> decltype(func(field.vec_f, args...))
+{
+  if      (field.memType == MemType::Float)  return func(field.vec_f, args...);
+  else if (field.memType == MemType::Double) return func(field.vec_d, args...);
+  else throw std::runtime_error("Type of field unsupported!");
+}
+
+template<typename FUNC, typename FIELD, typename... ARGS>
+inline auto
+field_operation2(FUNC func, FIELD& field1, FIELD& field2, ARGS&... args)
+-> decltype(func(field1.vec_f, field2.vec_d, args...))
+{
+  if      (memtype_is_float_float(field1.memType, field2.memType))   return func(field1.vec_f, field2.vec_f, args...);
+  else if (memtype_is_float_double(field1.memType, field2.memType))  return func(field1.vec_f, field2.vec_d, args...);
+  else if (memtype_is_double_float(field1.memType, field2.memType))  return func(field1.vec_d, field2.vec_f, args...);
+  else if (memtype_is_double_double(field1.memType, field2.memType)) return func(field1.vec_d, field2.vec_d, args...);
+  else throw std::runtime_error("Type of fields unsupported!");
+}
+// clang-format on
+
 struct DiffResult
 {
   size_t ndiff{ 0 };
@@ -80,60 +104,24 @@ diff(size_t n, const Field &field1, const Field &field2)
   auto hasMissvals = (field1.numMissVals || field2.numMissVals);
   if (hasMissvals)
     {
-      if (memtype_is_float_float(field1.memType, field2.memType))
-        {
-          for (size_t i = 0; i < n; ++i)
-            diff_kernel_mv(field1.vec_f[i], field2.vec_f[i], field1.missval, field2.missval, diffParam);
-        }
-      else if (memtype_is_float_double(field1.memType, field2.memType))
-        {
-          for (size_t i = 0; i < n; ++i)
-            diff_kernel_mv(field1.vec_f[i], field2.vec_d[i], field1.missval, field2.missval, diffParam);
-        }
-      else if (memtype_is_double_float(field1.memType, field2.memType))
-        {
-          for (size_t i = 0; i < n; ++i)
-            diff_kernel_mv(field1.vec_d[i], field2.vec_f[i], field1.missval, field2.missval, diffParam);
-        }
-      else
-        {
-          for (size_t i = 0; i < n; ++i)
-            diff_kernel_mv(field1.vec_d[i], field2.vec_d[i], field1.missval, field2.missval, diffParam);
-        }
+      auto func = [&](auto &v1, auto &v2, double mv1, double mv2) {
+        for (size_t i = 0; i < n; ++i) { diff_kernel_mv(v1[i], v2[i], mv1, mv2, diffParam); }
+      };
+
+      field_operation2(func, field1, field2, field1.missval, field2.missval);
     }
   else
     {
-      if (memtype_is_float_float(field1.memType, field2.memType))
-        {
-          for (size_t i = 0; i < n; ++i) { diff_kernel(field1.vec_f[i], field2.vec_f[i], diffParam); }
-        }
-      else if (memtype_is_float_double(field1.memType, field2.memType))
-        {
-          for (size_t i = 0; i < n; ++i) { diff_kernel(field1.vec_f[i], field2.vec_d[i], diffParam); }
-        }
-      else if (memtype_is_double_float(field1.memType, field2.memType))
-        {
-          for (size_t i = 0; i < n; ++i) { diff_kernel(field1.vec_d[i], field2.vec_f[i], diffParam); }
-        }
-      else
-        {
-          for (size_t i = 0; i < n; ++i) { diff_kernel(field1.vec_d[i], field2.vec_d[i], diffParam); }
-        }
+      auto func = [&](auto &v1, auto &v2) {
+        for (size_t i = 0; i < n; ++i) { diff_kernel(v1[i], v2[i], diffParam); }
+      };
+
+      field_operation2(func, field1, field2);
     }
 
   return diffParam;
 }
 
-template <typename FUNC, typename FIELD, typename... ARGS>
-inline auto
-field_operation(FUNC func, FIELD &field, ARGS &...args) -> decltype(func(field.vec_f, args...))
-{
-  if (field.memType == MemType::Float)
-    return func(field.vec_f, args...);
-  else
-    return func(field.vec_d, args...);
-}
-
 static void
 use_real_part(Field &field)
 {
@@ -141,6 +129,7 @@ use_real_part(Field &field)
     auto n = v.size() / 2;
     for (size_t i = 0; i < n; ++i) v[i] = v[i * 2];
   };
+
   return field_operation(func, field);
 }