refactor source files to split the simple algorithm implementations and their respective pipeline adapters into separate files

Author: mnikander

CMakeLists.txt

@@ -14,28 +14,49 @@ set(SOURCES )
 add_executable(unit_tests ${SOURCES}
                           test/main.cpp
                           test/meta/test_result.cpp
-                          test/test_all.cpp
-                          test/test_any.cpp
-                          test/test_catenate.cpp
-                          test/test_drop.cpp
-                          test/test_filter.cpp
+
+                          test/pipeline/test_all.cpp
+                          test/pipeline/test_any.cpp
+                          test/pipeline/test_catenate.cpp
+                          test/pipeline/test_drop.cpp
+                          test/pipeline/test_filter.cpp
+                          test/pipeline/test_gather.cpp
+                          test/pipeline/test_grade.cpp
+                          test/pipeline/test_iota.cpp
+                          test/pipeline/test_map.cpp
+                          test/pipeline/test_none.cpp
+                          test/pipeline/test_reduce.cpp
+                          test/pipeline/test_repeat.cpp
+                          test/pipeline/test_reverse.cpp
+                          test/pipeline/test_rank.cpp
+                          test/pipeline/test_rotate.cpp
+                          test/pipeline/test_scatter.cpp
+                          test/pipeline/test_size.cpp
+                          test/pipeline/test_take.cpp
+                          test/pipeline/test_xpr_pipe.cpp
+
+                          test/simple/test_all.cpp
+                          test/simple/test_any.cpp
+                          test/simple/test_catenate.cpp
+                          test/simple/test_drop.cpp
+                          test/simple/test_filter.cpp
+                          test/simple/test_gather.cpp
+                          test/simple/test_grade.cpp
+                          test/simple/test_iota.cpp
+                          test/simple/test_map.cpp
+                          test/simple/test_none.cpp
+                          test/simple/test_reduce.cpp
+                          test/simple/test_repeat.cpp
+                          test/simple/test_reverse.cpp
+                          test/simple/test_rank.cpp
+                          test/simple/test_rotate.cpp
+                          test/simple/test_scatter.cpp
+                          test/simple/test_shuffle.cpp
+                          test/simple/test_size.cpp
+                          test/simple/test_take.cpp
+                          test/simple/test_zip.cpp
+
                           test/test_functional.cpp
-                          test/test_gather.cpp
-                          test/test_grade.cpp
-                          test/test_iota.cpp
-                          test/test_map.cpp
-                          test/test_none.cpp
-                          test/test_reduce.cpp
-                          test/test_repeat.cpp
-                          test/test_reverse.cpp
-                          test/test_rank.cpp
-                          test/test_rotate.cpp
-                          test/test_scatter.cpp
-                          test/test_shuffle.cpp
-                          test/test_size.cpp
-                          test/test_take.cpp
-                          test/test_xpr_pipe.cpp
-                          test/test_zip.cpp
 )
 target_link_libraries(unit_tests ${GTEST_LIBRARIES} pthread)
 

src/_main.cpp

@@ -3,13 +3,13 @@
 #include "io/vector_stream.hpp"
 #include "meta/bind.hpp"
 #include "meta/global_datatypes.hpp"
-#include "catenate.hpp"
-#include "drop.hpp"
+#include "pipeline/catenate.hpp"
+#include "pipeline/drop.hpp"
+#include "pipeline/iota.hpp"
+#include "pipeline/map.hpp"
+#include "pipeline/reverse.hpp"
+#include "pipeline/take.hpp"
 #include "functional.hpp"
-#include "iota.hpp"
-#include "map.hpp"
-#include "reverse.hpp"
-#include "take.hpp"
 
 int main()
 {

src/pipeline/README.md

@@ -0,0 +1,5 @@
+# Pipeline adapters
+
+This folder contains a set of function objects.
+They serve as adapters which allow the simple functions to be used in a pipeline using the bash-style `|` operator.
+Due to the various function signatures and function overloads, these adapters are non-trivial and have to be written by hand to achieve a clean syntax for the pipelines.

src/all.hpp src/pipeline/all.hppsrc/all.hpp renamed to src/pipeline/all.hpp

@@ -3,24 +3,8 @@
 #include <algorithm>
 #include <functional>
 #include <vector>
-#include "meta/expression.hpp"
-#include "size.hpp"
-
-namespace nv {
-
-template<typename L, typename UnaryPred>
-bool all(std::vector<L> const& left, UnaryPred pred)
-{
-    return std::all_of(left.cbegin(), left.cend(), pred);
-}
-
-template<typename L, typename BinaryPred, typename R>
-bool all(std::vector<L> const& left, BinaryPred pred, std::vector<R> const& right)
-{
-    return std::equal(left.cbegin(), left.cend(), right.cbegin(), right.cend(), pred);
-}
-
-}
+#include "../meta/expression.hpp"
+#include "../simple/all.hpp"
 
 namespace xpr {
 

src/any.hpp src/pipeline/any.hppsrc/any.hpp renamed to src/pipeline/any.hpp

@@ -4,25 +4,9 @@
 #include <cstdint>
 #include <functional>
 #include <vector>
-#include "meta/expression.hpp"
+#include "../meta/expression.hpp"
 #include "size.hpp"
-
-namespace nv {
-
-template<typename L, typename UnaryPred>
-bool any(std::vector<L> const& left, UnaryPred pred)
-{
-    return std::any_of(left.cbegin(), left.cend(), pred);
-}
-
-template<typename L, typename BinaryPred, typename R>
-bool any(std::vector<L> const& left, BinaryPred pred, std::vector<R> const& right)
-{
-    int32_t count = std::min(size(left), size(right));
-    return !std::equal(left.cbegin(), left.cbegin()+count, right.cbegin(), right.cbegin()+count, [pred](auto l, auto r){ return !pred(l, r); });
-}
-
-}
+#include "../simple/any.hpp"
 
 namespace xpr {
 

src/pipeline/catenate.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <algorithm>
+#include <vector>
+#include "../meta/expression.hpp"
+#include "size.hpp"
+#include "../simple/catenate.hpp"
+
+namespace xpr {
+
+template <typename T>
+struct catenate : Expression<catenate<T>>
+{
+    catenate(T const& right) : _right{right} {}
+
+    std::vector<T> operator()(std::vector<T> const& left) const { return nv::catenate(left, _right); }
+    std::vector<T> operator()(T const& left) const { return nv::catenate(left, _right); }
+
+    const T _right;
+};
+
+// template specialization for std::vector
+template <typename T>
+struct catenate<std::vector<T>> : Expression<catenate<std::vector<T>>>
+{
+    catenate(std::vector<T> const& right) : _right{right} {}
+
+    std::vector<T> operator()(std::vector<T> const& left) const { return nv::catenate(left, _right); }
+    std::vector<T> operator()(T const& left) const { return nv::catenate(left, _right); }
+
+    const std::vector<T> _right;
+};
+
+}

src/pipeline/drop.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <algorithm>
+#include <cassert>
+#include <vector>
+#include "../meta/expression.hpp"
+#include "size.hpp"
+#include "../simple/drop.hpp"
+
+namespace xpr {
+
+struct drop : Expression<drop>
+{
+    drop(int count) : _count{count} {}
+
+    template<typename T>
+    std::vector<T> operator()(std::vector<T> const& v) const { return nv::drop(v, _count); }
+
+    const int _count;
+};
+
+struct drop_last : Expression<drop_last>
+{
+    drop_last(int count) : _count{count} {}
+
+    template<typename T>
+    std::vector<T> operator()(std::vector<T> const& v) const { return nv::drop_last(v, _count); }
+
+    const int _count;
+
+};
+
+}

src/filter.hpp src/pipeline/filter.hppsrc/filter.hpp renamed to src/pipeline/filter.hpp

@@ -3,20 +3,9 @@
 #include <algorithm>
 #include <iterator>
 #include <vector>
-#include "meta/expression.hpp"
+#include "../meta/expression.hpp"
 #include "size.hpp"
-
-namespace nv {
-
-template<typename T, typename UnaryPred>
-std::vector<T> filter(std::vector<T> const& v, UnaryPred op)
-{
-    std::vector<T> result{};
-    std::copy_if(v.cbegin(), v.cend(), std::back_inserter(result), op);
-    return result;
-}
-
-}
+#include "../simple/filter.hpp"
 
 namespace xpr {
 

src/pipeline/gather.hpp

@@ -0,0 +1,24 @@
+// naive implementation of 'gather' from nvidia thrust library
+// https://nvidia.github.io/cccl/thrust/api/groups/group__gathering.html
+
+#pragma once
+
+#include <cassert>
+#include <vector>
+#include "../meta/expression.hpp"
+#include "size.hpp"
+#include "../simple/gather.hpp"
+
+namespace xpr {
+
+struct gather : Expression<gather>
+{
+    gather(std::vector<int> const& order) : _order{order} {}
+
+    template<typename T>
+    std::vector<T> operator()(std::vector<T> const& v) const { return nv::gather(v, _order); }
+
+    std::vector<int> const _order;
+};
+
+}

src/pipeline/grade.hpp

@@ -0,0 +1,36 @@
+// implementation of APL algorithm 'grade'
+
+#pragma once
+
+#include <algorithm>
+#include <vector>
+#include "../meta/expression.hpp"
+#include "iota.hpp"
+#include "size.hpp"
+#include "../simple/grade.hpp"
+
+namespace xpr {
+
+template <typename BinaryOp>
+struct grade : Expression<grade<BinaryOp>>
+{
+    grade(BinaryOp op) : _op{op} {}
+
+    template<typename T>
+    std::vector<int> operator()(std::vector<T> const& v) const { return nv::grade(v, _op); }
+
+    BinaryOp const _op;
+};
+
+template <typename BinaryOp>
+struct stable_grade : Expression<stable_grade<BinaryOp>>
+{
+    stable_grade(BinaryOp op) : _op{op} {}
+
+    template<typename T>
+    std::vector<int> operator()(std::vector<T> const& v) const { return nv::stable_grade(v, _op); }
+
+    BinaryOp const _op;
+};
+
+}