cherrypicks from dev-0.7.0 (#83)

* new API :: device_type

* more constructors

Author: lgarithm

include/ttl/bits/flat_tensor_mixin.hpp

@@ -44,6 +44,7 @@ class flat_tensor_mixin
   public:
     using value_type = R;
     using shape_type = S;
+    using device_type = D;
 
     size_t data_size() const { return shape_.size() * sizeof(R); }
 

include/ttl/bits/std_tensor.hpp

@@ -41,6 +41,8 @@ class basic_tensor<R, basic_shape<0, Dim>, D, readwrite>
     using mixin::mixin;
 
   public:
+    basic_tensor(R *data) : mixin(data) {}
+
     basic_tensor(const basic_tensor<R, basic_shape<0, Dim>, D, owner> &t)
         : mixin(t.data())
     {
@@ -67,6 +69,8 @@ class basic_tensor<R, basic_shape<0, Dim>, D, readonly>
     using mixin::mixin;
 
   public:
+    basic_tensor(const R *data) : mixin(data) {}
+
     basic_tensor(const basic_tensor<R, basic_shape<0, Dim>, D, owner> &t)
         : mixin(t.data())
     {

include/ttl/bits/std_tensor_mixin.hpp

@@ -30,6 +30,7 @@ class basic_scalar_mixin
   public:
     using value_type = R;
     using shape_type = S;
+    using device_type = D;
 
     static constexpr auto rank = S::rank;  // == 0
 
@@ -112,6 +113,7 @@ class basic_tensor_mixin
   public:
     using value_type = R;
     using shape_type = S;
+    using device_type = D;
 
     using slice_type = basic_tensor<R, S, D, typename trait::Access>;
 

tests/_test_loc.cpp

@@ -0,0 +1,35 @@
+#include <cstdlib>
+#include <filesystem>
+#include <iostream>
+
+#include "testing.hpp"
+
+namespace fs = std::filesystem;
+
+int loc(const char *filename)
+{
+    FILE *fp = std::fopen(filename, "r");
+    if (fp == nullptr) { return 0; }
+    constexpr int max_line = 1 << 16;
+    char line[max_line];
+    int ln = 0;
+    while (std::fgets(line, max_line - 1, fp)) { ++ln; }
+    std::fclose(fp);
+    return ln;
+}
+
+TEST(test_loc, test1)
+{
+    std::string path = "/path/to/directory";
+    int tot = 0;
+    int n = 0;
+    for (const auto &entry : fs::directory_iterator("include/ttl/bits")) {
+        const int ln = loc(entry.path().c_str());
+        printf("%4d %s\n", ln, entry.path().c_str());
+        ASSERT_TRUE(ln <= 200);
+        tot += ln;
+        ++n;
+    }
+    printf("total: %d lines in %d files\n", tot, n);
+    ASSERT_TRUE(tot <= 2000);
+}

tests/test_scalar.cpp

@@ -0,0 +1,17 @@
+#include "testing.hpp"
+
+#include <ttl/tensor>
+
+TEST(scalar_test, test_constructor)
+{
+    {
+        ttl::tensor<int, 0> x;
+        ttl::tensor_ref<int, 0> r(x);
+        ttl::tensor_view<int, 0> v(x);
+    }
+    {
+        int value = 0;
+        ttl::tensor_ref<int, 0> r(&value);
+        ttl::tensor_view<int, 0> v(&value);
+    }
+}

tests/test_tensor.cpp

@@ -40,20 +40,24 @@ TEST(tensor_test, test1)
     ASSERT_EQ(sum, n * (n + 1) / 2);
 }
 
-template <bool write, typename T> struct test_assign_ {
+template <bool write, typename T>
+struct test_assign_ {
     void operator()(T &x, int v) { x = v; }
 };
 
-template <typename T> struct test_assign_<false, T> {
+template <typename T>
+struct test_assign_<false, T> {
     void operator()(T &x, int v) {}
 };
 
-template <bool write, typename T> void test_assign(T &&x, int v)
+template <bool write, typename T>
+void test_assign(T &&x, int v)
 {
     test_assign_<write, T>()(x, v);
 }
 
-template <typename T, bool write = true> struct test_5d_array {
+template <typename T, bool write = true>
+struct test_5d_array {
     void operator()(const T &t)
     {
         using R = typename T::value_type;
@@ -118,9 +122,13 @@ TEST(tensor_test, test3)
     test_5d_array<decltype(v), false>()(v);
 }
 
-template <typename R, uint8_t r> void ref_func(const tensor_ref<R, r> &x) {}
+template <typename R, uint8_t r>
+void ref_func(const tensor_ref<R, r> &x)
+{
+}
 
-template <typename R, uint8_t r> void test_auto_ref()
+template <typename R, uint8_t r>
+void test_auto_ref()
 {
     static_assert(std::is_convertible<tensor<R, r>, tensor_ref<R, r>>::value,
                   "can't convert to ref");
@@ -142,9 +150,13 @@ TEST(tensor_test, auto_ref)
     // f(t);  // NOT possible
 }
 
-template <typename R, uint8_t r> void view_func(const tensor_view<R, r> &x) {}
+template <typename R, uint8_t r>
+void view_func(const tensor_view<R, r> &x)
+{
+}
 
-template <typename R, uint8_t r> void test_auto_view()
+template <typename R, uint8_t r>
+void test_auto_view()
 {
     static_assert(std::is_convertible<tensor<R, r>, tensor_view<R, r>>::value,
                   "can't convert to view");
@@ -177,7 +189,8 @@ auto create_tensor_func()
 
 TEST(tensor_test, return_tensor) { auto t = create_tensor_func(); }
 
-template <typename R> R read_tensor_func(const tensor<R, 2> &t, int i, int j)
+template <typename R>
+R read_tensor_func(const tensor<R, 2> &t, int i, int j)
 {
     const R x = t.at(i, j);
     return x;
@@ -256,6 +269,8 @@ void test_static_properties(const ttl::internal::basic_tensor<R, S, D, A> &x)
     using T = ttl::internal::basic_tensor<R, S, D, A>;
     static_assert(std::is_same<typename T::value_type, R>::value,
                   "invalid value_type");
+    static_assert(std::is_same<typename T::device_type, D>::value,
+                  "invalid device_type");
     static_assert(T::rank == r, "invalid rank");
     auto x_shape = x.shape();
     static_assert(decltype(x_shape)::rank == r, "invalid rank of shape");
@@ -316,7 +331,8 @@ TEST(tensor_test, test_const_properties)
         "");
 }
 
-template <typename T> void test_slice_57_52_53_slice_19_38(const T &t)
+template <typename T>
+void test_slice_57_52_53_slice_19_38(const T &t)
 {
     const auto t1 = t.slice(0, 19);
     const auto t2 = t.slice(19, 57);
@@ -349,7 +365,8 @@ TEST(tensor_test, test_slice)
     }
 }
 
-template <typename T> void test_data_end(const T &t)
+template <typename T>
+void test_data_end(const T &t)
 {
     ASSERT_EQ(t.data_end(), t.data() + t.shape().size());
     {
@@ -359,7 +376,8 @@ template <typename T> void test_data_end(const T &t)
     }
 }
 
-template <typename R> void test_data_end_all()
+template <typename R>
+void test_data_end_all()
 {
     // using ttl::experimental::raw_ref;
     // using ttl::experimental::raw_view;