From 4b8824944bc8e286bbdb613277e080f718ef7c9e Mon Sep 17 00:00:00 2001
From: lg <lg4869@outlook.com>
Date: Tue, 7 Apr 2020 15:46:18 +0100
Subject: [PATCH 1/2] vec and mat

---
 include/ttl/bits/low_rank_tensor.hpp          | 76 +++++++++++++++++++
 include/ttl/bits/std_static_shape.hpp         | 29 +++++++
 include/ttl/experimental/low_rank_tensor      | 42 ++++++++++
 ...clude_ttl_experimental_low_rank_tensor.cpp | 41 ++++++++++
 tests/test_loc.cpp                            |  2 +-
 5 files changed, 189 insertions(+), 1 deletion(-)
 create mode 100644 include/ttl/bits/low_rank_tensor.hpp
 create mode 100644 include/ttl/bits/std_static_shape.hpp
 create mode 100644 include/ttl/experimental/low_rank_tensor
 create mode 100644 tests/test_include_ttl_experimental_low_rank_tensor.cpp

diff --git a/include/ttl/bits/low_rank_tensor.hpp b/include/ttl/bits/low_rank_tensor.hpp
new file mode 100644
index 0000000..336ba23
--- /dev/null
+++ b/include/ttl/bits/low_rank_tensor.hpp
@@ -0,0 +1,76 @@
+#pragma once
+#include <algorithm>
+#include <array>
+#include <utility>
+
+#include <ttl/bits/std_access_traits.hpp>
+#include <ttl/bits/std_device.hpp>
+#include <ttl/bits/std_static_shape.hpp>
+#include <ttl/bits/std_tensor_fwd.hpp>
+
+namespace ttl
+{
+namespace internal
+{
+template <typename R, typename Dim, Dim... ds>
+class basic_tensor<R, basic_static_shape<Dim, ds...>, host_memory, owner>
+{
+  protected:
+    using S = basic_static_shape<Dim, ds...>;
+    using data_t = std::array<R, S::dim>;
+
+    data_t data_;
+
+    template <typename F>
+    static void pointwise(const F &f, const data_t &x, const data_t &y,
+                          data_t &z)
+    {
+        std::transform(x.begin(), x.end(), y.begin(), z.begin(), f);
+    }
+
+  public:
+    using shape_type = S;
+    using dimension_type = Dim;
+
+    static constexpr auto rank = 1;
+    static constexpr Dim dim = S::dim;
+
+    basic_tensor(void *)
+    {
+        // no initialization
+    }
+
+    basic_tensor() { std::fill(data_.begin(), data_.end(), static_cast<R>(0)); }
+
+    explicit basic_tensor(data_t data) : data_(std::move(data)) {}
+
+    template <typename... C>
+    basic_tensor(const C &... c) : data_({static_cast<R>(c)...})
+    {
+        static_assert(sizeof...(C) == dim, "");
+    }
+
+    R *data() const { return data_.data(); }
+
+    const R &operator[](int i) const { return data_[i]; }
+
+    template <typename A>
+    basic_tensor<R, S, host_memory, owner>
+    operator+(const basic_tensor<R, S, host_memory, A> &y) const
+    {
+        data_t z;
+        pointwise(std::plus<R>(), data_, y.data_, z);
+        return basic_tensor<R, S, host_memory, owner>(std::move(z));
+    }
+
+    template <typename A>
+    basic_tensor<R, S, host_memory, owner>
+    operator-(const basic_tensor<R, S, host_memory, A> &y) const
+    {
+        data_t z;
+        pointwise(std::minus<R>(), data_, y.data_, z);
+        return basic_tensor<R, S, host_memory, owner>(std::move(z));
+    }
+};
+}  // namespace internal
+}  // namespace ttl
diff --git a/include/ttl/bits/std_static_shape.hpp b/include/ttl/bits/std_static_shape.hpp
new file mode 100644
index 0000000..d1f38c1
--- /dev/null
+++ b/include/ttl/bits/std_static_shape.hpp
@@ -0,0 +1,29 @@
+#pragma once
+#include <utility>
+
+namespace ttl
+{
+namespace internal
+{
+template <typename D, D... ds>
+struct int_seq_prod;
+
+template <typename D>
+struct int_seq_prod<D> {
+    static constexpr D value = 1;
+};
+
+template <typename D, D d0, D... ds>
+struct int_seq_prod<D, d0, ds...> {
+    static constexpr D value = d0 * int_seq_prod<D, ds...>::value;
+};
+
+template <typename D, D... ds>
+class basic_static_shape : public std::integer_sequence<D, ds...>
+{
+  public:
+    static constexpr auto rank = sizeof...(ds);
+    static constexpr D dim = int_seq_prod<D, ds...>::value;
+};
+}  // namespace internal
+}  // namespace ttl
diff --git a/include/ttl/experimental/low_rank_tensor b/include/ttl/experimental/low_rank_tensor
new file mode 100644
index 0000000..631392e
--- /dev/null
+++ b/include/ttl/experimental/low_rank_tensor
@@ -0,0 +1,42 @@
+// -*- mode: c++ -*-
+#pragma once
+#include <ttl/bits/low_rank_tensor.hpp>
+#include <ttl/bits/std_access_traits.hpp>
+
+namespace ttl
+{
+namespace internal
+{
+template <typename R, uint32_t n>
+using basic_fixed_vector =
+    basic_tensor<R, basic_static_shape<uint32_t, n>, host_memory, owner>;
+
+template <typename R, uint32_t m, uint32_t n>
+using basic_fixed_matrix =
+    basic_tensor<R, basic_static_shape<uint32_t, m, n>, host_memory, owner>;
+}  // namespace internal
+
+template <typename R, uint32_t n>
+using vec = internal::basic_fixed_vector<R, n>;
+
+template <typename R>
+using vec2 = vec<R, 2>;
+
+template <typename R>
+using vec3 = vec<R, 3>;
+
+template <typename R>
+using vec4 = vec<R, 4>;
+
+template <typename R, uint32_t m, uint32_t n = m>
+using mat = internal::basic_fixed_matrix<R, m, n>;
+
+template <typename R>
+using mat2 = mat<R, 2>;
+
+template <typename R>
+using mat3 = mat<R, 3>;
+
+template <typename R>
+using mat4 = mat<R, 4>;
+}  // namespace ttl
diff --git a/tests/test_include_ttl_experimental_low_rank_tensor.cpp b/tests/test_include_ttl_experimental_low_rank_tensor.cpp
new file mode 100644
index 0000000..3f41ab2
--- /dev/null
+++ b/tests/test_include_ttl_experimental_low_rank_tensor.cpp
@@ -0,0 +1,41 @@
+#include "testing.hpp"
+
+#include <ttl/experimental/low_rank_tensor>
+
+template <typename R, int n>
+void test_vec()
+{
+    using ttl::vec;
+    static_assert(sizeof(vec<R, n>) == sizeof(R) * n, "");
+}
+
+template <typename R, int m, int n = m>
+void test_mat()
+{
+    using ttl::mat;
+    static_assert(sizeof(mat<R, m, n>) == sizeof(R) * m * n, "");
+}
+
+TEST(ttl_low_rank_tensor_include_test, test_vec)
+{
+    // test_vec<int, 0>();
+    test_vec<int, 1>();
+    test_vec<int, 2>();
+    test_vec<int, 3>();
+}
+
+TEST(ttl_low_rank_tensor_include_test, test_mat)
+{
+    // test_mat<int, 0>();
+    test_mat<int, 1>();
+    test_mat<int, 2>();
+    test_mat<int, 3>();
+
+    test_mat<int, 1, 2>();
+    test_mat<int, 1, 3>();
+    test_mat<int, 1, 4>();
+
+    test_mat<int, 2, 3>();
+    test_mat<int, 2, 4>();
+    test_mat<int, 3, 4>();
+}
diff --git a/tests/test_loc.cpp b/tests/test_loc.cpp
index f5f499a..ea78c07 100644
--- a/tests/test_loc.cpp
+++ b/tests/test_loc.cpp
@@ -30,5 +30,5 @@ TEST(test_loc, test1)
         ++n;
     }
     printf("total: %d lines in %d files\n", tot, n);
-    ASSERT_TRUE(tot <= 2100);
+    ASSERT_TRUE(tot <= 2300);
 }

From cc1bbfba2e09b52fe8870a64a745f012de6548a6 Mon Sep 17 00:00:00 2001
From: lg <lg4869@outlook.com>
Date: Wed, 8 Apr 2020 23:01:23 +0100
Subject: [PATCH 2/2] scaler vector operations

---
 include/ttl/bits/low_rank_tensor.hpp          | 24 ++++++++++++++++++-
 ...clude_ttl_experimental_low_rank_tensor.cpp | 14 +++++++++++
 2 files changed, 37 insertions(+), 1 deletion(-)

diff --git a/include/ttl/bits/low_rank_tensor.hpp b/include/ttl/bits/low_rank_tensor.hpp
index 336ba23..28793bd 100644
--- a/include/ttl/bits/low_rank_tensor.hpp
+++ b/include/ttl/bits/low_rank_tensor.hpp
@@ -21,6 +21,12 @@ class basic_tensor<R, basic_static_shape<Dim, ds...>, host_memory, owner>
 
     data_t data_;
 
+    template <typename F>
+    static void pointwise(const F &f, const data_t &x, data_t &y)
+    {
+        std::transform(x.begin(), x.end(), y.begin(), f);
+    }
+
     template <typename F>
     static void pointwise(const F &f, const data_t &x, const data_t &y,
                           data_t &z)
@@ -50,10 +56,26 @@ class basic_tensor<R, basic_static_shape<Dim, ds...>, host_memory, owner>
         static_assert(sizeof...(C) == dim, "");
     }
 
-    R *data() const { return data_.data(); }
+    R *data() { return data_.data(); }
+
+    const R *data() const { return data_.data(); }
 
     const R &operator[](int i) const { return data_[i]; }
 
+    basic_tensor<R, S, host_memory, owner> operator-() const
+    {
+        data_t y;
+        pointwise(std::negate<R>(), data_, y);
+        return basic_tensor<R, S, host_memory, owner>(std::move(y));
+    }
+
+    basic_tensor<R, S, host_memory, owner> operator*(R x) const
+    {
+        data_t y;
+        pointwise([x = x](R a) { return a * x; }, data_, y);
+        return basic_tensor<R, S, host_memory, owner>(std::move(y));
+    }
+
     template <typename A>
     basic_tensor<R, S, host_memory, owner>
     operator+(const basic_tensor<R, S, host_memory, A> &y) const
diff --git a/tests/test_include_ttl_experimental_low_rank_tensor.cpp b/tests/test_include_ttl_experimental_low_rank_tensor.cpp
index 3f41ab2..0d18311 100644
--- a/tests/test_include_ttl_experimental_low_rank_tensor.cpp
+++ b/tests/test_include_ttl_experimental_low_rank_tensor.cpp
@@ -39,3 +39,17 @@ TEST(ttl_low_rank_tensor_include_test, test_mat)
     test_mat<int, 2, 4>();
     test_mat<int, 3, 4>();
 }
+
+TEST(ttl_low_rank_tensor_include_test, test_op)
+{
+    using ttl::vec;
+    vec<int, 2> x;
+    {
+        vec<int, 2> y = -x;
+        static_assert(sizeof(y) > 0, "");
+    }
+    {
+        vec<int, 2> y = x * 2;
+        static_assert(sizeof(y) > 0, "");
+    }
+}