ttl/algorithm (#30)

* init ttl/algorithm

* min/max

* fix build

Author: lgarithm

include/ttl/algorithm

@@ -0,0 +1,15 @@
+// # -*- mode: c++ -*-
+#pragma once
+
+#include <ttl/bits/std_tensor_algo.hpp>
+
+namespace ttl
+{
+using ttl::internal::argmax;
+using ttl::internal::cast;
+using ttl::internal::fill;
+using ttl::internal::hamming_distance;
+using ttl::internal::max;
+using ttl::internal::min;
+using ttl::internal::sum;
+}  // namespace ttl

include/ttl/bits/std_tensor_algo.hpp

@@ -0,0 +1,61 @@
+#pragma once
+#include <algorithm>
+#include <functional>
+
+#include <ttl/bits/std_shape.hpp>
+#include <ttl/bits/std_tensor.hpp>
+
+namespace ttl
+{
+namespace internal
+{
+template <typename R, typename S, typename D = typename S::dimension_type>
+D argmax(const basic_tensor_view<R, 1, S> &t)
+{
+    return std::max_element(t.data(), t.data_end()) - t.data();
+}
+
+template <typename R, typename R1, rank_t r, typename S>
+void cast(const basic_tensor_view<R, r, S> &x,
+          const basic_tensor_ref<R1, r, S> &y)
+{
+    std::transform(x.data(), x.data_end(), y.data(),
+                   [](const R &e) -> R1 { return static_cast<R1>(e); });
+}
+
+template <typename R, rank_t r, typename S>
+void fill(const basic_tensor_ref<R, r, S> &t, const R &x)
+{
+    std::fill(t.data(), t.data_end(), x);
+}
+
+template <typename R, rank_t r, typename S,
+          typename D = typename S::dimension_type>
+D hamming_distance(const basic_tensor_view<R, r, S> &x,
+                   const basic_tensor_view<R, r, S> &y)
+{
+    return std::inner_product(x.data(), x.data_end(), y.data(),
+                              static_cast<D>(0), std::plus<D>(),
+                              std::not_equal_to<R>());
+}
+
+template <typename R, rank_t r, typename S>
+R max(const basic_tensor_view<R, r, S> &t)
+{
+    return *std::max_element(t.data(), t.data_end());
+}
+
+template <typename R, rank_t r, typename S>
+R min(const basic_tensor_view<R, r, S> &t)
+{
+    return *std::min_element(t.data(), t.data_end());
+}
+
+template <typename R, rank_t r, typename S>
+R sum(const basic_tensor_view<R, r, S> &t)
+{
+    return std::accumulate(t.data(), t.data_end(), static_cast<R>(0));
+}
+
+}  // namespace internal
+}  // namespace ttl

tests/test_algo.cpp

@@ -0,0 +1,66 @@
+#include "testing.hpp"
+
+#include <ttl/algorithm>
+#include <ttl/tensor>
+
+TEST(tensor_algo_test, test_argmax)
+{
+    using R = float;
+    ttl::tensor<R, 1> t(10);
+    std::iota(t.data(), t.data_end(), 1);
+    ASSERT_EQ(static_cast<uint32_t>(9), ttl::argmax(view(t)));
+}
+
+TEST(tensor_algo_test, test_cast)
+{
+    int n = 10;
+
+    ttl::tensor<float, 1> x(n);
+    std::generate(x.data(), x.data_end(), [v = 0.1]() mutable {
+        auto u = v;
+        v += 0.2;
+        return u;
+    });
+
+    ttl::tensor<int, 1> y(n);
+    ttl::cast(view(x), ref(y));
+
+    ASSERT_EQ(5, ttl::sum(view(y)));
+}
+
+TEST(tensor_algo_test, test_fill)
+{
+    {
+        using R = int;
+        ttl::tensor<R, 1> t(10);
+        ttl::fill(ref(t), 1);
+    }
+    {
+        using R = float;
+        ttl::tensor<R, 1> t(10);
+        ttl::fill(ref(t), static_cast<R>(1.1));
+    }
+}
+
+TEST(tensor_algo_test, test_hamming_distance)
+{
+    using R = int;
+    int n = 0xffff;
+    ttl::tensor<R, 1> x(n);
+    ttl::fill(ref(x), -1);
+    ttl::tensor<R, 1> y(n);
+    ttl::fill(ref(y), 1);
+    ASSERT_EQ(static_cast<uint32_t>(n),
+              ttl::hamming_distance(view(x), view(y)));
+}
+
+TEST(tensor_algo_test, test_summaries)
+{
+    using R = int;
+    const int n = 10;
+    ttl::tensor<R, 1> x(n);
+    std::iota(x.data(), x.data_end(), -5);
+    ASSERT_EQ(-5, ttl::min(view(x)));
+    ASSERT_EQ(4, ttl::max(view(x)));
+    ASSERT_EQ(-5, ttl::sum(view(x)));
+}