modified

Author: chansoonlim

ctmd/concatenate.hpp

@@ -116,7 +116,7 @@ concatenate(std::tuple<InsTypes...> &&Ins) noexcept {
     // generate out
     using T = decltype([]<size_t... Is>(std::index_sequence<Is...>) {
         return std::common_type_t<
-            value_type_t<std::tuple_element_t<Is, ins_t>>...>{};
+            core::value_type_t<std::tuple_element_t<Is, ins_t>>...>{};
     }(std::make_index_sequence<num_ins>{}));
     auto out = ctmd::empty<T>(out_extents);
 

ctmd/core/broadcast.hpp

@@ -415,7 +415,7 @@ inline constexpr void batch(Func &&func, std::index_sequence<offsets...>,
         if constexpr (possibly_same_bexts) {
             const auto same_bexts =
                 [&]<size_t... Is>(std::index_sequence<Is...>) {
-                    return ctmd::same(slice_with_offset<ofst[Is], br[Is]>(
+                    return core::same(slice_with_offset<ofst[Is], br[Is]>(
                         std::get<Is>(ins_tuple).extents())...);
                 }(std::make_index_sequence<sizeof...(ins_t)>{});
 
@@ -435,8 +435,8 @@ inline constexpr void batch(Func &&func, std::index_sequence<offsets...>,
                     const auto bexts = slice_with_offset<ofst[0], br[0]>(
                         std::get<0>(ins_tuple).extents());
 
-                    constexpr size_t static_bsize = ctmd::static_size(bexts);
-                    const size_t bsize = ctmd::size(bexts);
+                    constexpr size_t static_bsize = core::static_size(bexts);
+                    const size_t bsize = core::size(bexts);
 
                     [&]<size_t... Is>(std::index_sequence<Is...>) {
                         detail::batch_impl<1>(

ctmd/core/convert.hpp

@@ -64,5 +64,15 @@ reshape(InType &&In, const extents_t &new_extents = extents_t{}) noexcept {
                                                           new_extents};
 }
 
+template <typename T>
+using to_mdspan_t = decltype(to_mdspan(std::declval<T>()));
+
+template <typename T>
+using to_mdcontainer_t =
+    std::conditional_t<to_mdspan_t<T>::rank() == 0,
+                       typename to_mdspan_t<T>::value_type,
+                       mdarray<typename to_mdspan_t<T>::value_type,
+                               typename to_mdspan_t<T>::extents_type>>;
+
 } // namespace core
 } // namespace ctmd

ctmd/core/type.hpp

@@ -65,6 +65,8 @@ concept mdspan_c = requires {
     typename T::accessor_type;
 };
 
+namespace core {
+
 template <extents_c exts_t>
 [[nodiscard]] inline constexpr size_t
 static_size(const exts_t &exts = exts_t{}) noexcept {
@@ -136,11 +138,13 @@ template <extents_c in1_t, extents_c in2_t, extents_c... ins_t>
     }
 }
 
+} // namespace core
+
 template <typename T, extents_c extent_t>
 using mdarray = std::conditional_t<
     extent_t::rank_dynamic() == 0,
     std::experimental::mdarray<T, extent_t, layout_right,
-                               std::array<T, static_size<extent_t>()>>,
+                               std::array<T, core::static_size<extent_t>()>>,
     std::experimental::mdarray<T, extent_t, layout_right, std::vector<T>>>;
 
 template <size_t start, size_t end>
@@ -150,11 +154,12 @@ using slice = std::experimental::strided_slice<
     std::integral_constant<size_t, 1>>;
 
 enum class MPMode : uint8_t {
-    NONE,
-    SIMD, // NOTE: Testing
-    CPUMP,
+    NONE,  // No parallelization
+    SIMD,  // SIMD parallelization
+    CPUMP, // CPU multi-processing with OpenMP
 };
 
+namespace core {
 namespace detail {
 
 template <typename T, typename = void> struct value_type_t_impl {
@@ -171,4 +176,5 @@ struct value_type_t_impl<T, std::void_t<typename T::value_type>> {
 template <typename T>
 using value_type_t = typename detail::value_type_t_impl<T>::type;
 
+} // namespace core
 } // namespace ctmd

ctmd/random/rand.hpp

@@ -75,7 +75,7 @@ inline constexpr void rand(InType &&In,
 
     if constexpr (in_t::rank_dynamic() == 0) {
         if (std::is_constant_evaluated()) {
-            using T = value_type_t<in_t>;
+            using T = core::value_type_t<in_t>;
 
             if constexpr (in_t::rank() == 0) {
                 constexpr auto data =

tests/empty/main.cpp

@@ -10,7 +10,7 @@ TEST(stack, 1) {
     constexpr auto x = md::empty<T>(md::extents<size_t, 1, 2, 3>{});
 
     constexpr auto is_same_extents =
-        md::same(x.extents(), md::extents<size_t, 1, 2, 3>{});
+        md::core::same(x.extents(), md::extents<size_t, 1, 2, 3>{});
 
     ASSERT_TRUE(is_same_extents);
 }
@@ -21,7 +21,7 @@ TEST(heap, 2) {
     const auto x = md::empty<T>(md::dims<3>{1, 2, 3});
 
     const auto is_same_extents =
-        md::same(x.extents(), md::extents<size_t, 1, 2, 3>{});
+        md::core::same(x.extents(), md::extents<size_t, 1, 2, 3>{});
 
     ASSERT_TRUE(is_same_extents);
 }

tests/empty_like/main.cpp

@@ -11,7 +11,7 @@ TEST(stack, 1) {
     constexpr auto y = md::empty_like(x);
 
     constexpr auto is_same_extents =
-        md::same(y.extents(), md::extents<size_t, 1, 2, 3>{});
+        md::core::same(y.extents(), md::extents<size_t, 1, 2, 3>{});
 
     ASSERT_TRUE(is_same_extents);
 }
@@ -23,7 +23,7 @@ TEST(heap, 2) {
     const auto y = md::empty_like(x);
 
     const auto is_same_extents =
-        md::same(y.extents(), md::extents<size_t, 1, 2, 3>{});
+        md::core::same(y.extents(), md::extents<size_t, 1, 2, 3>{});
 
     ASSERT_TRUE(is_same_extents);
 }

tests/linspace/main.cpp

@@ -42,19 +42,19 @@ TEST(stack, 2) {
         md::linspace<-1>(start, stop, md::extents<uint8_t, num>{}, true);
 
     static_assert(
-        md::same(out1.extents(), md::extents<size_t, num, ext1, ext2>{}));
+        md::core::same(out1.extents(), md::extents<size_t, num, ext1, ext2>{}));
     static_assert(out1(0, 0, 0) == start(0, 0));
     static_assert(out1(num - 1, ext1 - 1, ext2 - 1) ==
                   stop(ext1 - 1, ext2 - 1));
 
     static_assert(
-        md::same(out2.extents(), md::extents<size_t, ext1, num, ext2>{}));
+        md::core::same(out2.extents(), md::extents<size_t, ext1, num, ext2>{}));
     static_assert(out2(0, 0, 0) == start(0, 0));
     static_assert(out2(ext1 - 1, num - 1, ext2 - 1) ==
                   stop(ext1 - 1, ext2 - 1));
 
     static_assert(
-        md::same(out3.extents(), md::extents<size_t, ext1, ext2, num>{}));
+        md::core::same(out3.extents(), md::extents<size_t, ext1, ext2, num>{}));
     static_assert(out3(0, 0, 0) == start(0, 0));
     static_assert(out3(ext1 - 1, ext2 - 1, num - 1) ==
                   stop(ext1 - 1, ext2 - 1));