dev-0.8.0 (#85)

* more examples

* flat_tensor::ranked

* raw_tensor::typed<R, r>

* rename as_ranked -> ranked

* rename raw_shape -> flat_shape

* [[gnu::unused]]

* more detailed exception

* invalid_type_reification

* make make_shape constexpr

* flatten

* batch and vectorize

* raw_tensor::{rank,size,dims}

* new header <ttl/flat_shape>

* ref,view for basic_raw_tensor

* <ttl/type>

* move type_encoder to ttl/

* std_except.hpp

* fix cuda raw tensor (#86)

Author: lgarithm

cmake/examples.cmake

@@ -17,3 +17,10 @@ IF(USE_OPENCV)
     ADD_CPP_EXAMPLE(example-opencv examples/example_opencv.cpp)
     TARGET_LINK_LIBRARIES(example-opencv opencv_imgcodecs)
 ENDIF()
+
+FILE(GLOB examples examples/simple/*.cpp)
+FOREACH(src ${examples})
+    GET_FILENAME_COMPONENT(name ${src} NAME_WE)
+    STRING(REPLACE "_" "-" name ${name})
+    ADD_EXECUTABLE(${name} ${src})
+ENDFOREACH()

examples/simple/example_range.cpp

@@ -0,0 +1,8 @@
+#include <iostream>
+#include <ttl/range>
+
+int main()
+{
+    for (auto i : ttl::range(10)) { std::cout << i << std::endl; }
+    return 0;
+}

examples/simple/example_raw_tensor.cpp

@@ -0,0 +1,31 @@
+#include <ttl/experimental/flat_tensor>
+#include <ttl/experimental/raw_tensor>
+
+void f(const ttl::experimental::flat_tensor_view<int> &t) {}
+
+void f(const ttl::experimental::flat_tensor_view<float> &t) {}
+
+void f(const ttl::experimental::raw_tensor_view &t)
+{
+    using T = std::remove_reference<decltype(t)>::type;
+    switch (t.value_type()) {
+    case T::type<int>():
+        f(t.typed<int>());
+        break;
+    case T::type<float>():
+        f(t.typed<float>());
+        break;
+    }
+}
+
+int main()
+{
+    using ttl::experimental::raw_tensor;
+    raw_tensor x(raw_tensor::type<int>(), 2, 3);
+    raw_tensor y(raw_tensor::type<float>(), 2, 3);
+    f(ttl::experimental::raw_tensor_view(x));
+    f(ttl::experimental::raw_tensor_view(y));
+    // f(ttl::view(x));
+    // f(ttl::view(y));
+    return 0;
+}

examples/simple/example_tensor.cpp

@@ -0,0 +1,27 @@
+#include <iostream>
+#include <ttl/range>
+#include <ttl/tensor>
+
+void transpose(const ttl::tensor_view<int, 2> &x,
+               const ttl::tensor_ref<int, 2> &y)
+{
+    for (auto i : ttl::range<0>(x)) {
+        for (auto j : ttl::range<1>(x)) { y[j][i] = x[i][j]; }
+    }
+}
+
+int main()
+{
+    ttl::tensor<int, 2> m(2, 3);
+    int idx = 0;
+    for (const auto &row : m) {
+        for (int &x : row) { x = idx++; }
+    }
+    ttl::tensor<int, 2> n(3, 2);
+    transpose(ttl::view(m), ttl::ref(n));
+    for (const auto &row : n) {
+        for (int x : row) { std::cout << x << " "; }
+        std::cout << std::endl;
+    }
+    return 0;
+}

include/experimental/type_encoder

@@ -20,7 +20,7 @@ std::vector<D_out> arr2vec(const std::array<D_in, r> &a)
 }
 
 template <typename Dim = uint32_t>
-class basic_raw_shape
+class basic_flat_shape
 {
     using dim_t = Dim;
     const std::vector<dim_t> dims_;
@@ -29,15 +29,15 @@ class basic_raw_shape
     using dimension_type = Dim;
 
     template <typename... D>
-    explicit basic_raw_shape(D... d) : dims_({static_cast<dim_t>(d)...})
+    explicit basic_flat_shape(D... d) : dims_({static_cast<dim_t>(d)...})
     {
         static_assert(sizeof...(D) <= 0xff, "too many dimensions");
     }
 
-    explicit basic_raw_shape(const std::vector<dim_t> &dims) : dims_(dims) {}
+    explicit basic_flat_shape(const std::vector<dim_t> &dims) : dims_(dims) {}
 
     template <rank_t r, typename D>
-    explicit basic_raw_shape(const basic_shape<r, D> &shape)
+    explicit basic_flat_shape(const basic_shape<r, D> &shape)
         : dims_(std::move(arr2vec<Dim, D, r>(shape.dims())))
     {
     }
@@ -47,7 +47,7 @@ class basic_raw_shape
     dim_t size() const { return product<dim_t>(dims_.begin(), dims_.end()); }
 
     template <rank_t r>
-    basic_shape<r, dim_t> as_ranked() const
+    basic_shape<r, dim_t> ranked() const
     {
         // TODO: use contracts of c++20
         if (r != rank()) { throw std::invalid_argument("invalid rank"); }
@@ -57,6 +57,13 @@ class basic_raw_shape
     }
 
     const std::vector<dim_t> &dims() const { return dims_; }
+
+    bool operator==(const basic_flat_shape &s) const
+    {
+        return std::equal(dims_.begin(), dims_.end(), s.dims().begin());
+    }
+
+    bool operator!=(const basic_flat_shape &s) const { return !operator==(s); }
 };
 }  // namespace internal
 }  // namespace ttl

include/ttl/bits/raw_shape.hpp renamed to include/ttl/bits/flat_shape.hpp

@@ -1,6 +1,6 @@
 #pragma once
+#include <ttl/bits/flat_shape.hpp>
 #include <ttl/bits/flat_tensor_mixin.hpp>
-#include <ttl/bits/raw_shape.hpp>
 #include <ttl/bits/std_tensor.hpp>
 #include <ttl/bits/std_tensor_fwd.hpp>
 
@@ -9,10 +9,10 @@ namespace ttl
 namespace internal
 {
 template <typename R, typename Dim, typename D>
-class basic_tensor<R, basic_raw_shape<Dim>, D, owner>
-    : public flat_tensor_mixin<R, basic_raw_shape<Dim>, D, owner>
+class basic_tensor<R, basic_flat_shape<Dim>, D, owner>
+    : public flat_tensor_mixin<R, basic_flat_shape<Dim>, D, owner>
 {
-    using S = basic_raw_shape<Dim>;
+    using S = basic_flat_shape<Dim>;
     using mixin = flat_tensor_mixin<R, S, D, owner>;
 
   public:
@@ -28,10 +28,10 @@ class basic_tensor<R, basic_raw_shape<Dim>, D, owner>
 };
 
 template <typename R, typename Dim, typename D>
-class basic_tensor<R, basic_raw_shape<Dim>, D, readwrite>
-    : public flat_tensor_mixin<R, basic_raw_shape<Dim>, D, readwrite>
+class basic_tensor<R, basic_flat_shape<Dim>, D, readwrite>
+    : public flat_tensor_mixin<R, basic_flat_shape<Dim>, D, readwrite>
 {
-    using S = basic_raw_shape<Dim>;
+    using S = basic_flat_shape<Dim>;
     using mixin = flat_tensor_mixin<R, S, D, readwrite>;
 
   public:
@@ -53,10 +53,10 @@ class basic_tensor<R, basic_raw_shape<Dim>, D, readwrite>
 };
 
 template <typename R, typename Dim, typename D>
-class basic_tensor<R, basic_raw_shape<Dim>, D, readonly>
-    : public flat_tensor_mixin<R, basic_raw_shape<Dim>, D, readonly>
+class basic_tensor<R, basic_flat_shape<Dim>, D, readonly>
+    : public flat_tensor_mixin<R, basic_flat_shape<Dim>, D, readonly>
 {
-    using S = basic_raw_shape<Dim>;
+    using S = basic_flat_shape<Dim>;
     using mixin = flat_tensor_mixin<R, S, D, readonly>;
 
   public:
@@ -83,12 +83,12 @@ class basic_tensor<R, basic_raw_shape<Dim>, D, readonly>
 };
 
 template <typename R, typename D>
-using basic_flat_tensor = basic_tensor<R, basic_raw_shape<>, D, owner>;
+using basic_flat_tensor = basic_tensor<R, basic_flat_shape<>, D, owner>;
 
 template <typename R, typename D>
-using basic_flat_tensor_ref = basic_tensor<R, basic_raw_shape<>, D, readwrite>;
+using basic_flat_tensor_ref = basic_tensor<R, basic_flat_shape<>, D, readwrite>;
 
 template <typename R, typename D>
-using basic_flat_tensor_view = basic_tensor<R, basic_raw_shape<>, D, readonly>;
+using basic_flat_tensor_view = basic_tensor<R, basic_flat_shape<>, D, readonly>;
 }  // namespace internal
 }  // namespace ttl

include/ttl/bits/flat_tensor.hpp

@@ -1,5 +1,5 @@
 #pragma once
-#include <ttl/bits/raw_shape.hpp>
+#include <ttl/bits/flat_shape.hpp>
 #include <ttl/bits/std_shape.hpp>
 #include <ttl/bits/std_tensor_fwd.hpp>
 #include <ttl/bits/std_tensor_traits.hpp>
@@ -28,7 +28,7 @@ class flat_tensor_mixin
     using T = basic_tensor<R, basic_shape<r, Dim>, D, A1>;
 
     template <rank_t r, typename A1>
-    T<r, A1> ranked_as() const
+    [[deprecated]] T<r, A1> ranked_as() const
     {
         return T<r, A1>(data_.get(), shape_.template as_ranked<r>());
     }
@@ -61,13 +61,21 @@ class flat_tensor_mixin
     data_ptr data_end() const { return data_.get() + shape_.size(); }
 
     template <rank_t r>
-    T<r, readwrite> ref_as() const
+    auto ranked() const
+    {
+        using Access = typename basic_access_traits<A>::type;
+        using T = basic_tensor<R, basic_shape<r, Dim>, D, Access>;
+        return T(data(), shape_.template ranked<r>());
+    }
+
+    template <rank_t r>
+    [[deprecated]] T<r, readwrite> ref_as() const
     {
         return ranked_as<r, readwrite>();
     }
 
     template <rank_t r>
-    T<r, readonly> view_as() const
+    [[deprecated]] T<r, readonly> view_as() const
     {
         return ranked_as<r, readonly>();
     }

include/ttl/bits/flat_tensor_mixin.hpp

@@ -1,6 +1,6 @@
 #pragma once
+#include <ttl/bits/flat_shape.hpp>
 #include <ttl/bits/flat_tensor.hpp>
-#include <ttl/bits/raw_shape.hpp>
 #include <ttl/bits/raw_tensor_mixin.hpp>
 #include <ttl/bits/std_tensor_fwd.hpp>
 
@@ -9,11 +9,11 @@ namespace ttl
 namespace internal
 {
 template <typename Encoder, typename Dim, typename D>
-class basic_raw_tensor<Encoder, basic_raw_shape<Dim>, D, owner>
-    : public raw_tensor_mixin<Encoder, basic_raw_shape<Dim>, D, owner>
+class basic_raw_tensor<Encoder, basic_flat_shape<Dim>, D, owner>
+    : public raw_tensor_mixin<Encoder, basic_flat_shape<Dim>, D, owner>
 {
     using value_type_t = typename Encoder::value_type;
-    using S = basic_raw_shape<Dim>;
+    using S = basic_flat_shape<Dim>;
     using mixin = raw_tensor_mixin<Encoder, S, D, owner>;
     using allocator = basic_allocator<char, D>;
 
@@ -32,11 +32,11 @@ class basic_raw_tensor<Encoder, basic_raw_shape<Dim>, D, owner>
 };
 
 template <typename Encoder, typename Dim, typename D>
-class basic_raw_tensor<Encoder, basic_raw_shape<Dim>, D, readwrite>
-    : public raw_tensor_mixin<Encoder, basic_raw_shape<Dim>, D, readwrite>
+class basic_raw_tensor<Encoder, basic_flat_shape<Dim>, D, readwrite>
+    : public raw_tensor_mixin<Encoder, basic_flat_shape<Dim>, D, readwrite>
 {
     using value_type_t = typename Encoder::value_type;
-    using S = basic_raw_shape<Dim>;
+    using S = basic_flat_shape<Dim>;
     using mixin = raw_tensor_mixin<Encoder, S, D, readwrite>;
 
   public:
@@ -66,11 +66,11 @@ class basic_raw_tensor<Encoder, basic_raw_shape<Dim>, D, readwrite>
 };
 
 template <typename Encoder, typename Dim, typename D>
-class basic_raw_tensor<Encoder, basic_raw_shape<Dim>, D, readonly>
-    : public raw_tensor_mixin<Encoder, basic_raw_shape<Dim>, D, readonly>
+class basic_raw_tensor<Encoder, basic_flat_shape<Dim>, D, readonly>
+    : public raw_tensor_mixin<Encoder, basic_flat_shape<Dim>, D, readonly>
 {
     using value_type_t = typename Encoder::value_type;
-    using S = basic_raw_shape<Dim>;
+    using S = basic_flat_shape<Dim>;
     using mixin = raw_tensor_mixin<Encoder, S, D, readonly>;
 
   public:
@@ -106,12 +106,12 @@ class basic_raw_tensor<Encoder, basic_raw_shape<Dim>, D, readonly>
 };
 
 template <typename E, typename D>
-using raw_tensor = basic_raw_tensor<E, basic_raw_shape<>, D, owner>;
+using raw_tensor = basic_raw_tensor<E, basic_flat_shape<>, D, owner>;
 
 template <typename E, typename D>
-using raw_tensor_ref = basic_raw_tensor<E, basic_raw_shape<>, D, readwrite>;
+using raw_tensor_ref = basic_raw_tensor<E, basic_flat_shape<>, D, readwrite>;
 
 template <typename E, typename D>
-using raw_tensor_view = basic_raw_tensor<E, basic_raw_shape<>, D, readonly>;
+using raw_tensor_view = basic_raw_tensor<E, basic_flat_shape<>, D, readonly>;
 }  // namespace internal
 }  // namespace ttl