Add conversion from contiguous range to ndview

Author: elius1

doc/vt/ndarray/view/constructor.md

@@ -2,12 +2,22 @@ vt::ndview::ndview
 ==================
 
 ```c++
+// (1)
 constexpr ndview(const std::array<std::size_t, N>& shape, T* data) noexcept;
+// (2)
+template<ndview_compatible_range<T> R>
+constexpr ndview(R&& r) noexcept requires(N == 1);
+// (3)
+constexpr ndview(
+    std::initializer_list<std::remove_cv_t<T>> il
+) noexcept requires(std::is_const_v<T> && N == 1);
 ```
 
-Constructs the view for the given shape over the given data.
+Constructs a view from given data, a range or initializer list.
 
-The behavior is undefined if the array pointed to by `data` contains less than `shape[0] * ... * shape[N-1]` elements.
+1. Constructs the view for the given shape over the given data. The behavior is undefined if the array pointed to by `data` contains less than `shape[0] * ... * shape[N-1]` elements.
+2. Constructs the 1D view from the given contiguous range.
+3. Constructs the 1D view from the given initializer list.
 
 Parameters
 ----------
@@ -16,3 +26,32 @@ Parameters
 --------- | --------------------------------------------------------------------
 **shape** | an array containing the size of the data in each dimension
 **data**  | a pointer to the array containing the data that is to be viewed into
+**r**     | a contiguous range to view into
+**il**    | an initializer list to view into
+
+Example
+-------
+
+```c++
+#include <vt/ndarray/view.hpp>
+#include <iostream>
+
+int sum(vt::ndview<const int, 1> x) {
+    int sum_x = 0;
+    for (int x_i : x) sum_x += x_i;
+    return sum_x;
+}
+
+int main() {
+    const std::array<int, 4> x = { 1, 2, 3, 4 };
+    // A contiguous range, like std::array, can implicitly convert to a 1D
+    // vt::ndview:
+    std::cout << sum(x) << '\n';
+}
+```
+
+Output:
+
+```
+10
+```

include/vt/ndarray/impl/view.ipp

@@ -42,6 +42,23 @@ constexpr ndview<T, N>::ndview(
 }
 
 
+template<typename T, std::size_t N>
+template<ndview_compatible_range<T> R>
+constexpr ndview<T, N>::ndview(R&& r) noexcept requires(N == 1) :
+    ndview{{ std::ranges::size(r) }, std::ranges::data(r)}
+{
+}
+
+
+template<typename T, std::size_t N>
+constexpr ndview<T, N>::ndview(
+    std::initializer_list<std::remove_cv_t<T>> il
+) noexcept requires(std::is_const_v<T> && N == 1) :
+    ndview{{ il.size() }, il.begin()}
+{
+}
+
+
 template<typename T, std::size_t N>
 template<indexer... Index>
 constexpr decltype(auto) ndview<T, N>::operator[](

include/vt/ndarray/view.hpp

@@ -27,11 +27,35 @@
 #include <cstddef>
 #include <iterator>
 #include <ostream>
+#include <ranges>
 #include <type_traits>
 
 
 namespace vt {
 
+template<typename T, std::size_t N>
+class ndview;
+
+template<typename>
+struct is_ndview : std::false_type {};
+
+template<typename T, std::size_t N>
+struct is_ndview<ndview<T, N>> : std::true_type {};
+
+template<typename T>
+inline constexpr bool is_ndview_v = is_ndview<T>::value;
+
+template<typename R, typename T>
+concept ndview_compatible_range =
+    std::is_convertible_v<
+        std::remove_reference_t<std::ranges::range_reference_t<R>>(*)[],
+        T(*)[]
+    >
+    && std::ranges::contiguous_range<R>
+    && std::ranges::sized_range<R>
+    && (std::ranges::borrowed_range<R> || std::is_const_v<T>)
+    && !is_ndview_v<R>;
+
 template<typename T, std::size_t N>
 class ndview {
     static_assert(N > 0);
@@ -54,6 +78,13 @@ class ndview {
         T* data_
     ) noexcept;
 
+    template<ndview_compatible_range<T> R>
+    constexpr ndview(R&& r) noexcept requires(N == 1);
+
+    constexpr ndview(
+        std::initializer_list<std::remove_cv_t<T>> il
+    ) noexcept requires(std::is_const_v<T> && N == 1);
+
     template<indexer... Index>
     constexpr decltype(auto) operator[](
         Index... idx

test/vt/ndarray/view_test.cpp

@@ -40,6 +40,39 @@ TEST_CASE(
 }
 
 
+TEST_CASE(
+    "A 1D vt::ndview can be implicitly constructed from a contiguous range",
+    "[ndarray][view]"
+) {
+    const std::array<int, 4> data = { 3, 1, 4, 1 };
+    const vt::ndview<const int, 1> view = data;
+
+    REQUIRE(view.shape(0) == 4);
+    CHECK(std::equal(data.begin(), data.end(), view.data()));
+}
+
+
+TEST_CASE(
+    "A 1D vt::ndview can be implicitly constructed from an initializer list",
+    "[ndarray][view]"
+) {
+    const vt::ndview<const int, 1> view = { 3, 1, 4, 1 };
+
+    REQUIRE(view.shape(0) == 4);
+
+    const std::array<int, 4> expected = { 3, 1, 4, 1 };
+    CHECK(std::equal(expected.begin(), expected.end(), view.data()));
+}
+
+
+TEST_CASE(
+    "A vt::ndview is a contiguous range",
+    "[ndarray][view]"
+) {
+    STATIC_REQUIRE(std::ranges::contiguous_range<vt::ndview<int, 3>>);
+}
+
+
 TEST_CASE(
     "A vt::ndview can index into 1-dimensional data",
     "[ndarray][view]"