Fix rank/size for 0-size builtin arrays

These can't be used for much of anything, but at least don't return wrong
values.

* ra/base.hh (is_builtin): Include 0-size, 1-rank arrays here.
  (rank_s): Special case for 0-size arrays.
* test/types.cc: Basic tests.
* ra/arrays.hh (SmallArray): Fix constraint on { T ... } constructor.
* test/small-0.cc: Add test.

Author: lloda

ra/arrays.hh

@@ -247,14 +247,13 @@ SmallArray<T, Dimv_, std::tuple<nested_args ...>>
 
     constexpr SmallArray(ra::none_t) {}
     constexpr SmallArray() {}
-// T not is_scalar [ra44]
-    constexpr SmallArray(T const & t) { std::ranges::fill(cp, t); }
+    constexpr SmallArray(T const & t) { std::ranges::fill(cp, t); } // [ra44]
 // braces, row-major and nested
-    constexpr SmallArray(T const & x0, std::convertible_to<T> auto const & ... x) requires (1!=rank())
+    constexpr SmallArray(T const & x0, std::convertible_to<T> auto const & ... x) requires (1+sizeof...(x)==size()) // FIXME p1219??
     {
         view() = { static_cast<T>(x0), static_cast<T>(x) ... };
     }
-    constexpr SmallArray(nested_args const & ... x) requires (1!=rank() || 1!=len(0)) { view() = { x ... }; } // FIXME p1219??
+    constexpr SmallArray(nested_args const & ... x) requires (1!=rank() || 1!=len(0)) { view() = { x ... }; }
     constexpr SmallArray(auto const & x) { view() = x; }
     constexpr SmallArray(Iterator auto && x) { view() = RA_FW(x); }
 #define RA_ASSIGNOPS(OP)                                                \
@@ -380,93 +379,82 @@ struct Container: public ViewBig<typename storage_traits<Store>::T *, R>
         store = storage_traits<Store>::create(filldimv(ra::iter(s), dimv));
         cp = storage_traits<Store>::data(store);
     }
-
-// provided so that {} calls sharg constructor below.
-    constexpr static auto zdims = std::apply([](auto ... i){ return std::array<Dim, (R==ANY)?1:R>{Dim{i*0, 1} ... }; }, mp::iota<(R==ANY)?1:R>{});
-    constexpr Container(): View(zdims, nullptr) {}
-    constexpr Container() requires (R==0): Container({}, none) {}
-    constexpr Container(auto const & x): Container(ra::shape(x), none) { view() = x; }
-    constexpr Container(braces<T, R> x) requires (R!=ANY): Container(braces_shape<T, R>(x), none) { view() = x; }
-#define RA_BRACES(N) constexpr Container(braces<T, N> x) requires (R==ANY): Container(braces_shape<T, N>(x), none) { view() = x; }
-    RA_FE(RA_BRACES, 1, 2, 3, 4)
-#undef RA_BRACES
-
-    using sharg = decltype(shape(std::declval<View>().iter()));
-// sharg overloads handle {...} arguments. Size check is at conversion if sharg is Small.
-    constexpr Container(sharg const & s, none_t) { init(s); }
-    constexpr Container(sharg const & s, auto const & x): Container(s, none) { view() = x; }
-    constexpr Container(sharg const & s, braces<T, R> x) requires (1==R): Container(s, none) { view() = x; }
-
 // FIXME requires copyable Y, which conflicts with semantics of view_.operator=. store(x) avoids the conflict for Big, but not for Unique. Should construct in place like std::vector.
+// FIXME skip ravel-through-iterator if rank is 1.
     constexpr void
     fill1(auto && xbegin, dim_t xsize)
     {
         RA_CK(size()==xsize, "Mismatched sizes ", size(), " ", xsize, ".");
         std::ranges::copy_n(RA_FW(xbegin), xsize, begin());
     }
 
-// shape + row-major ravel.
-// FIXME explicit it-is-ravel mark. Also iter<n> initializers.
-// FIXME regular (no need for fill1) for ANY if rank is 1.
-    constexpr Container(sharg const & s, std::initializer_list<T> x) requires (1!=R): Container(s, none) { fill1(x.begin(), x.size()); }
-// FIXME remove these two
-    constexpr Container(sharg const & s, auto * p): Container(s, none) { fill1(p, size()); } // FIXME fake check
-    constexpr Container(sharg const & s, auto && pbegin, dim_t psize): Container(s, none) { fill1(RA_FW(pbegin), psize); }
-// for shape argument that doesn't convert implicitly to sharg
+    constexpr static auto zdims = std::apply([](auto ... i){ return std::array<Dim, (R==ANY)?1:R>{Dim{i*0, 1} ... }; }, mp::iota<(R==ANY)?1:R>{});
+    constexpr Container(): View(zdims, nullptr) {}
+    constexpr Container() requires (R==0): Container({}, none) {}
+    constexpr Container(auto const & x): Container(ra::shape(x), ra::none) { view() = x; }
+    constexpr Container(braces<T, R> x) requires (R!=ANY): Container(braces_shape<T, R>(x), ra::none) { view() = x; }
+#define RA_BRACES(N) constexpr Container(braces<T, N> x) requires (R==ANY): Container(braces_shape<T, N>(x), ra::none) { view() = x; }
+    RA_FE(RA_BRACES, 1, 2, 3, 4)
+#undef RA_BRACES
+// FIXME replace shape + row-major ravel by explicit it-is-ravel mark, also iter<n> initializers.
     constexpr Container(auto const & s, none_t) { init(s); }
     constexpr Container(auto const & s, auto const & x): Container(s, none) { view() = x; }
-    constexpr Container(auto const & s, std::initializer_list<T> x): Container(s, none) { fill1(x.begin(), x.size()); }
+    constexpr Container(auto const & s, braces<T, R> x) requires (1==R): Container(s, none) { view() = x; }
+    constexpr Container(auto const & s, std::initializer_list<T> x) requires (1!=R): Container(s, none) { fill1(x.begin(), x.size()); }
+// sharg overloads handle {...} arguments.
+    using sharg = decltype(shape(std::declval<View>()));
+    constexpr Container(sharg const & s, none_t): Container(ra::iter(s), ra::none) {}
+    constexpr Container(sharg const & s, auto const & x): Container(ra::iter(s), x) {}
+    constexpr Container(sharg const & s, braces<T, R> x) requires (1==R): Container(ra::iter(s), x) {}
+    constexpr Container(sharg const & s, std::initializer_list<T> x) requires (1!=R): Container(ra::iter(s), x) {}
+// FIXME remove these two
+    constexpr Container(sharg const & s, auto * p): Container(ra::iter(s), none) { fill1(p, size()); }
+    constexpr Container(sharg const & s, auto && pbegin, dim_t psize): Container(ra::iter(s), none) { fill1(RA_FW(pbegin), psize); }
 
 // resize first axis or full shape. Only for some kinds of store.
     constexpr void resize(dim_t const s)
     {
         if constexpr (ANY==R) { RA_CK(0<rank()); } else { static_assert(0<=R); }
-        dimv[0].len = s;
-        store.resize(size()); cp = store.data();
+        dimv[0].len = s; store.resize(size()); cp = store.data();
     }
     constexpr void resize(dim_t const s, T const & t)
     {
         static_assert(ANY==R || 0<R); RA_CK(0<rank());
-        dimv[0].len = s;
-        store.resize(size(), t); cp = store.data();
+        dimv[0].len = s; store.resize(size(), t); cp = store.data();
     }
     constexpr void resize(auto const & s) requires (1==rank_s(s))
     {
         store.resize(filldimv(ra::iter(s), dimv)); cp = store.data();
     }
-// template + RA_FW wouldn't work for push_back(brace-enclosed-list).
+// auto && + RA_FW wouldn't work for push_back(brace-enclosed-list). p1219??
     constexpr void push_back(T && t)
     {
         if constexpr (ANY==R) { RA_CK(1==rank()); } else { static_assert(1==R); }
-        store.push_back(std::move(t));
-        ++dimv[0].len; cp = store.data();
+        store.push_back(std::move(t)); ++dimv[0].len; cp = store.data();
     }
     constexpr void push_back(T const & t)
     {
         if constexpr (ANY==R) { RA_CK(1==rank()); } else { static_assert(1==R); }
-        store.push_back(t);
-        ++dimv[0].len; cp = store.data();
+        store.push_back(t); ++dimv[0].len; cp = store.data();
     }
     constexpr void emplace_back(auto && ... a)
     {
         if constexpr (ANY==R) { RA_CK(1==rank()); } else { static_assert(1==R); }
-        store.emplace_back(RA_FW(a) ...);
-        ++dimv[0].len; cp = store.data();
+        store.emplace_back(RA_FW(a) ...); ++dimv[0].len; cp = store.data();
     }
     constexpr void pop_back()
     {
         if constexpr (ANY==R) { RA_CK(1==rank()); } else { static_assert(1==R); }
         RA_CK(0<dimv[0].len, "Empty array pop_back().");
-        --dimv[0].len;
-        store.pop_back();
+        --dimv[0].len; store.pop_back();
     }
     constexpr decltype(auto) back(this auto && self) { return RA_FW(self).view().back(); }
     constexpr decltype(auto) operator()(this auto && self, auto && ... i) { return RA_FW(self).view()(RA_FW(i) ...); }
     constexpr decltype(auto) operator[](this auto && self, auto && ... i) { return RA_FW(self).view()(RA_FW(i) ...); }
     constexpr decltype(auto) at(this auto && self, auto const & i) { return RA_FW(self).view().at(i); }
     constexpr auto begin(this auto && self) { assert(c_order(self.view().dimv)); return self.view().data(); }
     constexpr auto end(this auto && self) { return self.view().data()+self.size(); }
-    template <rank_t c=0> constexpr auto iter(this auto && self) { if constexpr (1==R && 0==c) { return ptr(self.data(), self.size()); } else { return RA_FW(self).view().template iter<c>(); } }
+    template <rank_t c=0> constexpr auto iter(this auto && self) { if constexpr (1==R && 0==c) return ptr(self.data(), self.size()); else return RA_FW(self).view().template iter<c>(); }
     constexpr auto iter(this auto && self, rank_t c) { return RA_FW(self).view().iter(c); }
     constexpr operator T & () { return view(); }
     constexpr operator T const & () const { return view(); }

ra/base.hh

@@ -316,8 +316,7 @@ constexpr bool inside(dim_t i, dim_t b) { return 0<=i && i<b; }
 constexpr bool any(bool const x) { return x; } // extended in ra.hh
 constexpr bool every(bool const x) { return x; }
 
-// adaptor that inserts construct() calls to convert value init into default init. See https://stackoverflow.com/a/21028912
-// default storage for Big.
+// convert value init into default init (https://stackoverflow.com/a/21028912). Default storage for Big.
 template <class T, class A=std::allocator<T>>
 struct default_init_allocator: public A
 {
@@ -400,18 +399,19 @@ template <> constexpr bool is_scalar_def<std::partial_ordering> = true;
 
 RA_IS_DEF(is_iterator, Iterator<A>)
 template <class A> concept is_ra = is_iterator<A> || Slice<A>;
-template <class A> concept is_builtin = std::is_array_v<std::remove_cvref_t<A>>;
+template <class A> concept is_builtin_0 = requires (A & v) { []<class T>(T (&x)[0]){}(v); };
+template <class A> concept is_builtin = std::is_array_v<std::remove_cvref_t<A>> || is_builtin_0<A>;
 RA_IS_DEF(is_fov, !is_scalar<A> && !is_ra<A> && !is_builtin<A> && std::ranges::bidirectional_range<A>)
 
 template <class VV> requires (!std::is_void_v<VV>)
 consteval rank_t
 rank_s()
 {
     using V = std::remove_cvref_t<VV>;
-    if constexpr (is_builtin<V>) {
-        return std::rank_v<V>;
-    } else if constexpr (is_fov<V>) {
+    if constexpr (is_builtin_0<V> || is_fov<V>) {
         return 1;
+    } else if constexpr (is_builtin<V>) {
+        return std::rank_v<V>;
     } else if constexpr (requires { V::rank(); }) {
         return V::rank();
     } else if constexpr (requires (V v) { v.rank(); }) {

test/ra-14.cc

@@ -21,6 +21,11 @@ int main()
     using int2 = ra::Small<int, 2>;
     tr.section("Values");
     {
+        tr.section("Rank 0 constructor");
+        {
+            ra::Big<int> a({}, ra::none);
+            tr.test_eq(0, rank(a));
+        }
         tr.section("From var rank 0 [ra15]");
         {
             ra::Big<int2> a({}, {{ 1, 2 }});

test/small-0.cc

@@ -565,5 +565,15 @@ int main()
         cout << c << endl;
         cout << d << endl;
     }
+    tr.section("constructor from cells");
+    {
+        ra::Small<int, 4> a { 1, 2, 3, 4 };
+        ra::Small<int, 4> b { 3, 1, 4, 2 };
+        ra::Small<int, 3, 4> ref { { 1, 2, 3, 4 }, { 3, 1, 4, 2 }, { 1, 2, 3, 4 } };
+        ra::Small<int, 3, 4> c { a, b, a.view() };
+        tr.test_eq(ref, c);
+        auto d = [](auto && a, auto  && b, auto && c) { return ra::Small<int, 3, 4> { a, b, c }; }(a, b, a.view());
+        tr.test_eq(ref, d);
+    }
     return tr.summary();
 }

test/types.cc

@@ -1,7 +1,7 @@
 // -*- mode: c++; coding: utf-8 -*-
 // ra-ra/test - Show what types conform to what type predicates.
 
-// (c) Daniel Llorens - 2016-2017
+// (c) Daniel Llorens - 2016-2026
 // This library is free software; you can redistribute it and/or modify it under
 // the terms of the GNU Lesser General Public License as published by the Free
 // Software Foundation; either version 3 of the License, or (at your option) any
@@ -257,5 +257,19 @@ int main()
         std::println(std::cout, "no float128_t support!");
 #endif // RA_FLOAT128
     }
+    tr.section("zero rank arrays");
+    {
+        static_assert(ra::is_builtin<decltype((ra::dim_t[1]){})>);
+        static_assert(ra::is_builtin<decltype((ra::dim_t[0]){})>);
+        static_assert(1==ra::rank_s((ra::dim_t[1]){}));
+        static_assert(1==ra::rank_s((ra::dim_t[0]){}));
+        static_assert(1==ra::size_s((ra::dim_t[1]){}));
+        static_assert(0==ra::size_s((ra::dim_t[0]){}));
+        int z[0];
+        static_assert(1==ra::rank_s(z));
+        static_assert(0==ra::size_s(z));
+        static_assert(1==ra::rank(z));
+        static_assert(0==ra::size(z));
+    }
     return tr.summary();
 }