Reduce copying in to_vector_{1,2,3}d

The to_vector_{1,2,3}d helper functions simply forward the const-ref when it is already a vector_{1,2,3}d. This avoids making unnecesary copies.

Author: lacc97

source/matplot/util/common.h

@@ -163,49 +163,51 @@ namespace matplot {
         return r;
     }
 
-    template <class T> std::vector<vector_2d> to_vector_3d(const T &v) {
-        std::vector<vector_2d> r(v.size());
-        size_t matrix_index = 0;
-        for (auto matrix_it = v.begin(); matrix_it != v.end();
-             ++matrix_it, ++matrix_index) {
-            r[matrix_index] = vector_2d(matrix_it->size());
-            size_t i = 0;
-            for (auto v_it = matrix_it->begin(); v_it != matrix_it->end();
-                 ++v_it, ++i) {
-                r[matrix_index][i] = vector_1d(v_it->size());
-                size_t j = 0;
-                for (auto vj_it = v_it->begin(); vj_it != v_it->end();
-                     ++vj_it, ++j) {
-                    r[matrix_index][i][j] = static_cast<double>(*vj_it);
-                }
-            }
+    namespace detail {
+        template <typename T, typename U>
+        using forward_or_copy =
+            std::conditional_t<std::is_same_v<T, U>, const U &, U>;
+    }
+
+    template <class T>
+    detail::forward_or_copy<T, vector_1d> to_vector_1d(const T &v) {
+        if constexpr (std::is_same_v<T, vector_1d>) {
+            return v;
+        } else {
+            using std::begin, std::end;
+
+            return vector_1d(begin(v), end(v));
         }
-        return r;
     }
 
-    template <class T, class DESTINATION_VALUE_TYPE = double>
-    vector_2d to_vector_2d(const T &v) {
-        std::vector<std::vector<DESTINATION_VALUE_TYPE>> r(v.size());
-        size_t i = 0;
-        for (auto v_it = v.begin(); v_it != v.end(); ++v_it, ++i) {
-            r[i] = std::vector<DESTINATION_VALUE_TYPE>(v_it->size());
-            size_t j = 0;
-            for (auto vj_it = v_it->begin(); vj_it != v_it->end();
-                 ++vj_it, ++j) {
-                r[i][j] = static_cast<DESTINATION_VALUE_TYPE>(*vj_it);
-            }
+    template <class T>
+    detail::forward_or_copy<T, vector_2d> to_vector_2d(const T &v) {
+        if constexpr (std::is_same_v<T, vector_2d>) {
+            return v;
+        } else {
+            using std::begin, std::end;
+
+            vector_2d r(std::distance(begin(v), end(v)));
+            std::transform(
+                begin(v), end(v), r.begin(),
+                [](auto &&e) -> vector_1d { return to_vector_1d(e); });
+            return r;
         }
-        return r;
     }
 
-    template <class T, class DESTINATION_VALUE_TYPE = double>
-    vector_1d to_vector_1d(const T &v) {
-        std::vector<DESTINATION_VALUE_TYPE> r(v.size());
-        size_t i = 0;
-        for (auto v_it = v.begin(); v_it != v.end(); ++v_it, ++i) {
-            r[i] = static_cast<DESTINATION_VALUE_TYPE>(*v_it);
+    template <class T>
+    detail::forward_or_copy<T, std::vector<vector_2d>> to_vector_3d(const T &v) {
+        if constexpr (std::is_same_v<T, std::vector<vector_2d>>) {
+            return v;
+        } else {
+            using std::begin, std::end;
+
+            std::vector<vector_2d> r(std::distance(begin(v), end(v)));
+            std::transform(
+                begin(v), end(v), r.begin(),
+                [](auto &&e) -> vector_2d { return to_vector_2d(e); });
+            return r;
         }
-        return r;
     }
 
     template <class T> inline T norm(const std::vector<T> &v) {