Support reverse(small)

* ra/small.hh (reverse): As stated.
* test/ra-1.cc, test/view-ops.cc: Test.

Author: lloda

docs/index.html

@@ -2507,11 +2507,20 @@ See also @ref{x-imag_part,@code{imag_part}}.
 @end defun
 
 @cindex @code{reverse}
-@anchor{x-reverse} @defun reverse view axis
+@anchor{x-reverse} @defun reverse view k
 Create a new view by reversing axis @var{k} of @var{view}.
 
 This is equivalent to @code{view(ra::dots<k>, ra::iota(ra::len, ra::len-1, -1))}.
 
+If @var{view} has static dimensions, then @var{k} must be a static constant, e.g.
+@example
+@verbatim
+ra::Small<int, 3, 2> a = {{1, 2, 3}, {4, 5, 6}};
+auto z = reverse(a, ra::ic<0>); // z has static dimensions
+@end verbatim
+@result{} z = @{@{3, 2, 1@}, @{6, 5, 4@}@}
+@end example
+
 This operation does not work on arbitrary array expressions yet. @c TODO FILL
 
 @end defun

docs/ra-ra.texi

@@ -391,8 +391,7 @@ template <class ... A> constexpr bool tomap = ((is_ra_pos<A> || is_special<A>) |
 
 // Sometimes we can't do shape(std::declval<V>()) even for static shape :-/ FIXME
 template <class VV>
-constexpr auto shape_s = []
-{
+constexpr auto shape_s = []{
     using V = std::remove_cvref_t<VV>;
     if constexpr (constexpr rank_t rs=rank_s<V>(); 0==rs) {
         return std::array<dim_t, 0> {};

ra/base.hh

@@ -524,15 +524,14 @@ with_shape(std::initializer_list<S> && s, X && x) { return with_shape<E>(start(s
 // --------------------
 
 template <class P, rank_t RANK>
-constexpr ViewBig<P, RANK>
+constexpr auto
 reverse(ViewBig<P, RANK> const & view, int k=0)
 {
     RA_CHECK(inside(k, view.rank()), "Bad axis ", k, " for rank ", view.rank(), ".");
     ViewBig<P, RANK> r = view;
-    if (auto & dim=r.dimv[k]; dim.len!=0) {
-        r.cp += dim.step*(dim.len-1);
-        dim.step *= -1;
-    }
+    auto & dim = r.dimv[k];
+    dim.step *= -1;
+    if (dim.len!=0) { r.cp += dim.step*(1-dim.len); }
     return r;
 }
 

ra/big.hh

@@ -24,8 +24,7 @@ inline std::ostream &
 operator<<(std::ostream & o, Dim const & dim) { return (o << "[Dim " << dim.len << " " << dim.step << "]"); }
 
 template <auto v, int n>
-constexpr auto vdrop = []
-{
+constexpr auto vdrop = []{
     std::array<Dim, ssize(v)-n> r;
     for (int i=0; i<int(r.size()); ++i) { r[i] = v[n+i]; }
     return r;
@@ -314,8 +313,7 @@ struct filterdims<prev, I0, I ...>
     constexpr static int dst = stretch ? (ssize(prev) - (0 + ... + beatable<I>.src)) : beatable<I0>.dst;
     constexpr static int src = stretch ? (ssize(prev) - (0 + ... + beatable<I>.src)) : beatable<I0>.src;
     constexpr static auto next = filterdims<vdrop<prev, src>, I ...>::dimv;
-    constexpr static auto dimv = []
-    {
+    constexpr static auto dimv = []{
         std::array<Dim, dst+ssize(next)> r;
         for (int i=0; i<dst; ++i) { r[i] = prev[i]; }
         for (int i=0; i<ssize(next); ++i) { r[dst+i] = next[i]; }
@@ -328,8 +326,7 @@ struct filterdims<prev, I0, I ...>
 {
     constexpr static int src = beatable<I0>.src;
     constexpr static auto next = filterdims<vdrop<prev, src>, I ...>::dimv;
-    constexpr static auto dimv = []
-    {
+    constexpr static auto dimv = []{
         std::array<Dim, 1+ssize(next)> r;
         r[0] = Dim { I0::nn, prev[0].step * I0::gets() };
         for (int i=0; i<ssize(next); ++i) { r[1+i] = next[i]; }
@@ -373,25 +370,13 @@ struct ViewSmall
     consteval static dim_t size() { return std::apply([](auto ... i) { return (i.len * ... * 1); }, dimv); }
 
     P cp;
+    constexpr ViewSmall const & view() const { return *this; }
+    constexpr P data() const { return cp; }
+    constexpr explicit ViewSmall(P cp_): cp(cp_) {}
 // exclude all T and sub constructors by making T & sub noarg
     constexpr static bool have_braces = std::is_reference_v<decltype(*cp)>;
     using T = std::conditional_t<have_braces, std::remove_reference_t<decltype(*cp)>, noarg>;
     using sub = typename nested_arg<T, Dimv>::sub;
-
-    constexpr ViewSmall const & view() const { return *this; }
-    constexpr P data() const { return cp; }
-
-    constexpr explicit ViewSmall(P cp_): cp(cp_) {}
-// cf RA_ASSIGNOPS_SELF [ra38] [ra34]
-    ViewSmall const & operator=(ViewSmall const & x) const { start(*this) = x; return *this; }
-    constexpr ViewSmall(ViewSmall const & s) = default;
-
-    template <class X> requires (!std::is_same_v<std::decay_t<X>, T>)
-    constexpr ViewSmall const & operator=(X && x) const { start(*this) = x; return *this; }
-#define ASSIGNOPS(OP)                                                   \
-    constexpr ViewSmall const & operator OP(auto && x) const { start(*this) OP x; return *this; }
-    FOR_EACH(ASSIGNOPS, *=, +=, -=, /=)
-#undef ASSIGNOPS
 // if T isn't is_scalar [ra44]
     constexpr ViewSmall const &
     operator=(T const & t) const
@@ -412,6 +397,15 @@ struct ViewSmall
     {
         ra::iter<-1>(*this) = x; return *this;
     }
+// cf RA_ASSIGNOPS_SELF [ra38] [ra34]
+    ViewSmall const & operator=(ViewSmall const & x) const { start(*this) = x; return *this; }
+    constexpr ViewSmall(ViewSmall const & s) = default;
+    template <class X> requires (!std::is_same_v<std::decay_t<X>, T>)
+    constexpr ViewSmall const & operator=(X && x) const { start(*this) = x; return *this; }
+#define ASSIGNOPS(OP)                                                   \
+    constexpr ViewSmall const & operator OP(auto && x) const { start(*this) OP x; return *this; }
+    FOR_EACH(ASSIGNOPS, *=, +=, -=, /=)
+#undef ASSIGNOPS
 
     template <int k>
     constexpr static dim_t
@@ -597,6 +591,21 @@ transpose_dims(auto const & s, auto const & src, auto & dst)
 
 RA_IS_DEF(cv_viewsmall, (std::is_convertible_v<A, ViewSmall<decltype(std::declval<A>().data()), ic_t<A::dimv>>>));
 
+template <class K=ic_t<0>>
+constexpr auto
+reverse(cv_viewsmall auto && a_, K k = K {})
+{
+    decltype(auto) a = a_.view();
+    using A = std::decay_t<decltype(a)>;
+    constexpr auto rdimv = [&]{
+        std::remove_const_t<decltype(A::dimv)> rdimv = A::dimv;
+        RA_CHECK(inside(k, ssize(rdimv)), "Bad axis ", K::value, " for rank ", ssize(rdimv), ".");
+        rdimv[k].step *= -1;
+        return rdimv;
+    }();
+    return ViewSmall<decltype(a.cp), ic_t<rdimv>>(0==rdimv[k].len ? a.cp : a.cp + rdimv[k].step*(1-rdimv[k].len));
+}
+
 template <int ... Iarg>
 constexpr auto
 transpose(cv_viewsmall auto && a_, ilist_t<Iarg ...>)
@@ -607,7 +616,7 @@ transpose(cv_viewsmall auto && a_, ilist_t<Iarg ...>)
     constexpr static auto src = A::dimv;
     static_assert(ra::size(src)==ra::size(s), "Bad size for transposed axes list.");
     constexpr static rank_t dstrank = (0==ra::size(s)) ? 0 : 1 + std::ranges::max(s);
-    constexpr static auto dst = [&]() { std::array<Dim, dstrank> dst; transpose_dims(s, src, dst); return dst; }();
+    constexpr static auto dst = [&]{ std::array<Dim, dstrank> dst; transpose_dims(s, src, dst); return dst; }();
     return ViewSmall<decltype(a.cp), ic_t<dst>>(a.data());
 }
 
@@ -641,8 +650,7 @@ constexpr auto
 explode(cv_viewsmall auto && a)
 {
     constexpr static rank_t ru = sizeof(value_t<sup_t>)==sizeof(value_t<decltype(a)>) ? 0 : 1;
-    constexpr static auto bdimv = [&a]()
-    {
+    constexpr static auto bdimv = [&a]{
         std::array<Dim, ra::rank_s(a)-rank_s<sup_t>()-ru> bdimv;
         explode_dims<sup_t, value_t<decltype(a)>>(a.dimv, bdimv);
         return bdimv;

ra/small.hh

@@ -222,7 +222,7 @@ int main()
     TEST(ply_ravel)
     TEST(ply_fixed)
 #undef TEST
-    tr.section("reverse (ref & non ref), traverse");
+    tr.section("big reverse (ref & non ref), traverse");
     {
         A2 A({2, 3}, { 1, 2, 3, 4, 5, 6 });
         A2 B({2, 3}, { 1, 2, 3, 4, 5, 6 });
@@ -243,9 +243,8 @@ int main()
         CheckPly<A2>(tr, "(i)", reverse(reverse(A, 0), 1), B);
         CheckPly<A2>(tr, "(j)", reverse(reverse(A, 0), 1), reverse(reverse(B, 0), 1));
     }
-    tr.section("reverse & transpose (ref & non ref), traverse");
+    tr.section("big reverse & transpose (ref & non ref), traverse");
     {
-        using A2 = ra::Unique<int, 2>;
         A2 A({2, 2}, { 1, 2, 3, 4 });
         A2 B({2, 2}, { 1, 2, 3, 4 });
 
@@ -264,5 +263,26 @@ int main()
         CheckPly<A2>(tr, "(k)", reverse(reverse(transpose(A, ilist_t<1, 0>{}), 1), 0), B);
         CheckPly<A2>(tr, "(l)", A, reverse(reverse(transpose(B, ilist_t<1, 0>{}), 1), 0));
     }
+    tr.section("small reverse (ref & non ref), traverse");
+    {
+        ra::Small<int, 2, 3> A = { 1, 2, 3, 4, 5, 6 };
+        ra::Small<int, 2, 3> B = { 1, 2, 3, 4, 5, 6 };
+
+        CheckPly<A2>(tr, "(a)", A, B);
+        CheckPly<A2>(tr, "(b)", reverse(A, ra::ic<0>), B);
+        CheckPly<A2>(tr, "(c)", A, reverse(B, ra::ic<0>));
+        CheckPly<A2>(tr, "(d)", reverse(A, ra::ic<0>), reverse(B, ra::ic<0>));
+
+        CheckPly<A2>(tr, "(e)", reverse(A, ra::ic<1>), B);
+        CheckPly<A2>(tr, "(f)", A, reverse(B, ra::ic<1>));
+        CheckPly<A2>(tr, "(g)", reverse(A, ra::ic<1>), reverse(B, ra::ic<1>));
+
+// When BOTH steps are negative, B is still compact and this can be reduced to a single loop.
+// TODO Enforce that the loop is linearized over both dimensions.
+
+        CheckPly<A2>(tr, "(h)", A, reverse(reverse(B, ra::ic<0>), ra::ic<1>));
+        CheckPly<A2>(tr, "(i)", reverse(reverse(A, ra::ic<0>), ra::ic<1>), B);
+        CheckPly<A2>(tr, "(j)", reverse(reverse(A, ra::ic<0>), ra::ic<1>), reverse(reverse(B, ra::ic<0>), ra::ic<1>));
+    }
     return tr.summary();
 }

test/ra-1.cc

@@ -466,6 +466,7 @@ int main()
         tr.test_eq(a, 1+ra::Small<int, 3, 2> {{0, 1}, {2, 3}, {4, 5}});
     }
     tr.section("ViewSmall as iota<w>");
+// in order to replace Ptr<>, we must support Len both in P and in Dimv.
     {
         constexpr ra::ViewSmall<ra::Seq<ra::dim_t>, ra::ic_t<std::array {ra::Dim {ra::UNB, 1}}>>
             i0(ra::Seq<ra::dim_t> {0});

test/small-1.cc

@@ -19,30 +19,40 @@ template <class A>
 void CheckReverse(TestRecorder & tr, A && a)
 {
     std::iota(a.begin(), a.end(), 1);
-    cout << "a: " << a << endl;
-    auto b0 = reverse(a, 0);
-    auto c0 = a(ra::iota(ra::len, ra::len-1, -1));
+    auto bd = reverse(a);
+    auto b0 = reverse(a, ra::ic<0>);
     double check0[24] = { 17, 18, 19, 20,   21, 22, 23, 24,
                           9, 10, 11, 12,  13, 14, 15, 16,
                           1, 2, 3, 4,     5, 6, 7, 8 };
     tr.test(std::ranges::equal(check0, check0+24, b0.begin(), b0.end()));
-    tr.test_eq(b0, c0);
+    tr.test(std::ranges::equal(check0, check0+24, bd.begin(), bd.end()));
+// FIXME ViewSmall doesn't support these subscripts
+    if constexpr (ra::ANY==size_s(a)) {
+        auto c0 = a(ra::iota(ra::len, ra::len-1, -1));
+        tr.test_eq(b0, c0);
+    }
 
-    auto b1 = reverse(a, 1);
-    auto c1 = a(ra::dots<1>, ra::iota(ra::len, ra::len-1, -1));
+    auto b1 = reverse(a, ra::ic<1>);
     double check1[24] = { 5, 6, 7, 8,      1, 2, 3, 4,
                           13, 14, 15, 16,  9, 10, 11, 12,
                           21, 22, 23, 24,  17, 18, 19, 20 };
     tr.test(std::ranges::equal(check1, check1+24, b1.begin(), b1.end()));
-    tr.test_eq(b1, c1);
+// FIXME ViewSmall doesn't support these subscripts
+    if constexpr (ra::ANY==size_s(a)) {
+        auto c1 = a(ra::dots<1>, ra::iota(ra::len, ra::len-1, -1));
+        tr.test_eq(b1, c1);
+    }
 
-    auto b2 = reverse(a, 2);
-    auto c2 = a(ra::dots<2>, ra::iota(ra::len, ra::len-1, -1));
+    auto b2 = reverse(a, ra::ic<2>);
     double check2[24] = { 4, 3, 2, 1,      8, 7, 6, 5,
                           12, 11, 10, 9,   16, 15, 14, 13,
                           20, 19, 18, 17,  24, 23, 22, 21 };
     tr.test(std::ranges::equal(check2, check2+24, b2.begin(), b2.end()));
-    tr.test_eq(b2, c2);
+// FIXME ViewSmall doesn't support these subscripts
+    if constexpr (ra::ANY==size_s(a)) {
+        auto c2 = a(ra::dots<2>, ra::iota(ra::len, ra::len-1, -1));
+        tr.test_eq(b2, c2);
+    }
 }
 
 template <class A>
@@ -75,6 +85,7 @@ int main()
     {
         CheckReverse(tr, ra::Unique<double>({ 3, 2, 4 }, ra::none));
         CheckReverse(tr, ra::Unique<double, 3>({ 3, 2, 4 }, ra::none));
+        CheckReverse(tr, ra::Small<double, 3, 2, 4>(ra::none));
     }
     tr.section("transpose of 0 rank");
     {