Tests for reframe() used as transpose()

* ra/expr.hh (reframe): Take dest as function argument.
* test/wrank.cc: As stated.

Author: lloda

ra/big.hh

@@ -492,7 +492,7 @@ template <class E> requires (ANY==size_s<E>())
 struct concrete_type_<E> { using type = Big<ncvalue_t<E>, rank_s<E>()>; };
 
 template <class E> requires (0!=rank_s<E>() && ANY!=size_s<E>())
-struct concrete_type_<E> { using type = SmallArray<ncvalue_t<E>, ic_t<default_dims<shape_s<E>>>>; };
+struct concrete_type_<E> { using type = SmallArray<ncvalue_t<E>, ic_t<default_dims(shape_s<E>)>>; };
 
 template <class E> using concrete_type = std::conditional_t<(0==rank_s<E>() && !is_ra<E>), std::decay_t<E>,
                                                             typename concrete_type_<E>::type>;

ra/expr.hh

@@ -223,7 +223,7 @@ maybe_step()
 
 template <class I, class N=dim_c<UNB>, class S=dim_c<1>>
 constexpr auto
-ptr(I && i, N && n = N {}, S && s = maybe_step<S>())
+ptr(I && i, N && n=N {}, S && s=maybe_step<S>())
 {
     if constexpr (std::ranges::bidirectional_range<std::remove_reference_t<I>>) {
         static_assert(std::is_same_v<dim_c<UNB>, N>, "Object has own length.");
@@ -283,8 +283,7 @@ struct Reframe<A, ilist_t<di ...>, ilist_t<i ...>>
     constexpr static int orig(int k) { int r=-1; (void)((di==k && (r=i, 1)) || ...); return r; }
     constexpr static dim_t len_s(int k)
     {
-        int l=orig(k);
-        return l>=0 ? std::decay_t<A>::len_s(l) : UNB;
+        int l=orig(k); return l>=0 ? std::decay_t<A>::len_s(l) : UNB;
     }
     constexpr static dim_t
     len(int k) requires (requires { std::decay_t<A>::len(k); })
@@ -321,16 +320,15 @@ struct Reframe<A, ilist_t<di ...>, ilist_t<i ...>>
     constexpr decltype(auto) operator*() const { return *a; }
     constexpr auto save() const { return a.save(); }
     constexpr void load(auto const & p) { a.load(p); }
-// FIXME if Dest preserves axis order (?) which wrank does
     constexpr void mov(auto const & s) { a.mov(s); }
 };
 
 // Optimize nop case. TODO If A is CellBig, etc. beat Dest on it, same for eventual transpose_expr<>.
-template <class Dest, class A>
+template <class A, class Dest>
 constexpr decltype(auto)
-reframe(A && a)
+reframe(A && a, Dest)
 {
-    if constexpr (std::is_same_v<Dest, mp::iota<Reframe<A, Dest>::rank()>>) {
+    if constexpr (std::is_same_v<Dest, mp::iota<mp::len<Dest>>>) {
         return RA_FWD(a);
     } else {
         return Reframe<A, Dest> { RA_FWD(a) };
@@ -339,9 +337,9 @@ reframe(A && a)
 
 template <int w=0, class I=dim_t, class N=dim_c<UNB>, class S=dim_c<1>>
 constexpr auto
-iota(N && n = N {}, I && i = 0, S && s = maybe_step<S>())
+iota(N && n=N {}, I && i=0, S && s=maybe_step<S>())
 {
-    return reframe<ilist_t<w>>(Ptr<Seq<sarg<I>>, sarg<N>, sarg<S>> { {RA_FWD(i)}, RA_FWD(n), RA_FWD(s) });
+    return reframe(Ptr<Seq<sarg<I>>, sarg<N>, sarg<S>> { {RA_FWD(i)}, RA_FWD(n), RA_FWD(s) }, ilist_t<w>{});
 }
 
 #define DEF_TENSORINDEX(w) constexpr auto JOIN(_, w) = iota<w>();
@@ -613,7 +611,7 @@ constexpr bool
 agree_verb(ilist_t<i ...>, V const & v, T const & ... t)
 {
     using FM = Framematch<V, std::tuple<T ...>>;
-    return agree_op(FM::op(v), reframe<mp::ref<typename FM::R, i>>(ra::start(t)) ...);
+    return agree_op(FM::op(v), reframe(ra::start(t), mp::ref<typename FM::R, i>{}) ...);
 }
 
 
@@ -656,7 +654,7 @@ constexpr auto
 map_verb(ilist_t<i ...>, Op && op, P && ... p)
 {
     using FM = Framematch<Op, std::tuple<P ...>>;
-    return map_(FM::op(RA_FWD(op)), reframe<mp::ref<typename FM::R, i>>(RA_FWD(p)) ...);
+    return map_(FM::op(RA_FWD(op)), reframe(RA_FWD(p), mp::ref<typename FM::R, i>{}) ...);
 }
 
 constexpr auto

ra/ply.hh

@@ -301,7 +301,7 @@ struct STLIterator
         over = true;
     }
     constexpr STLIterator & operator++() { if constexpr (ANY==rank_s(a)) { next(rank(a)-1); } else { next<rank_s(a)-1>(); } return *this; }
-    constexpr void operator++(int) { ++(*this); } // see p0541 and p2550. Or just avoid.
+    constexpr void operator++(int) { ++(*this); }
 };
 
 template <class A> STLIterator(A &&) -> STLIterator<A>;

ra/small.hh

@@ -68,8 +68,8 @@ filldim(auto && shape, auto & dimv)
     return s;
 }
 
-template <auto lenv> constexpr auto
-default_dims = []{ std::array<Dim, ra::size(lenv)> dimv; filldim(lenv, dimv); return dimv; }();
+consteval auto
+default_dims(auto const & lv) { std::array<Dim, ra::size(lv)> dv; filldim(lv, dv); return dv; };
 
 constexpr auto
 shape(auto const & v, auto && e)
@@ -349,7 +349,7 @@ struct nested_arg<T, Dimv>
 {
     constexpr static auto sn = ssize(Dimv::value)-1;
     constexpr static auto s = std::apply([](auto ... i) { return std::array<dim_t, sn> { Dimv::value[i].len ... }; }, mp::iota<sn, 1> {});
-    using sub = std::conditional_t<0==sn, T, SmallArray<T, ic_t<default_dims<s>>>>;
+    using sub = std::conditional_t<0==sn, T, SmallArray<T, ic_t<default_dims(s)>>>;
 };
 
 template <class P> struct reconst_t { using type = void; };
@@ -559,7 +559,7 @@ SmallArray<T, Dimv, std::tuple<nested_args ...>>
 };
 
 template <class T, dim_t ... lens>
-using Small = SmallArray<T, ic_t<default_dims<std::array<dim_t, sizeof...(lens)> {lens ...}>>>;
+using Small = SmallArray<T, ic_t<default_dims(std::array<dim_t, sizeof...(lens)> {lens ...})>>;
 
 template <class A0, class ... A> SmallArray(A0, A ...) -> Small<A0, 1+sizeof...(A)>;
 
@@ -714,7 +714,7 @@ constexpr auto
 start(is_builtin_array auto && t)
 {
     using T = std::remove_all_extents_t<std::remove_reference_t<decltype(t)>>; // preserve const
-    return ViewSmall<T *, ic_t<default_dims<ra::shape(t)>>>(peel(t)).iter();
+    return ViewSmall<T *, ic_t<default_dims(ra::shape(t))>>(peel(t)).iter();
 }
 
 } // namespace ra

test/small-1.cc

@@ -73,7 +73,7 @@ int main()
     }
     tr.section("static step computation");
     {
-        auto dims = ra::default_dims<std::array<ra::dim_t, 3> {3, 4, 5}>;
+        auto dims = ra::default_dims(std::array<ra::dim_t, 3> {3, 4, 5});
         tr.info("step 0").test_eq(20, dims[0].step);
         tr.info("step 1").test_eq(5, dims[1].step);
         tr.info("step 2").test_eq(1, dims[2].step);
@@ -466,7 +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.
+// in order to replace Ptr<>, we must support Len in View::P and View::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/wrank.cc

@@ -47,8 +47,8 @@ void nested_wrank_demo(V && v, A && a, B && b)
         using FM = ra::Framematch<V, tuple<decltype(a.iter()), decltype(b.iter())>>;
         cout << "width of fm: " << ra::mp::len<typename FM::R> << endl;
         cout << ra::mp::print_ilist_t<typename FM::R> {} << endl;
-        auto af0 = ra::reframe<ra::mp::ref<typename FM::R, 0>>(a.iter());
-        auto af1 = ra::reframe<ra::mp::ref<typename FM::R, 1>>(b.iter());
+        auto af0 = reframe(a.iter(), ra::mp::ref<typename FM::R, 0>{});
+        auto af1 = reframe(b.iter(), ra::mp::ref<typename FM::R, 1>{});
         cout << "af0: " << sizeof(af0) << endl;
         cout << "af1: " << sizeof(af1) << endl;
         {
@@ -107,8 +107,8 @@ int main()
             using FM = ra::Framematch<decltype(v), tuple<decltype(a.iter()), decltype(b.iter())>>;
             cout << "width of fm: " << ra::mp::len<FM::R> << endl;
             cout << ra::mp::print_ilist_t<FM::R> {} << endl;
-            auto af0 = ra::reframe<ra::mp::ref<FM::R, 0>>(a.iter());
-            auto af1 = ra::reframe<ra::mp::ref<FM::R, 1>>(b.iter());
+            auto af0 = reframe(a.iter(), ra::mp::ref<FM::R, 0>{});
+            auto af1 = reframe(b.iter(), ra::mp::ref<FM::R, 1>{});
             cout << "af0: " << sizeof(af0) << endl;
             cout << "af1: " << sizeof(af1) << endl;
             auto ewv = ra::map_(FM::op(v), af0, af1);
@@ -354,5 +354,16 @@ int main()
             .test_eq(c, from([o = from(std::multiplies<>(), a, b)](auto i, auto j) { return o.at(std::array {i, j}); },
                              ra::iota(3), ra::iota(4)));
     }
+    tr.section("Reframe as transpose");
+    {
+        ra::ViewSmall<ra::Seq<int>, ra::ic_t<ra::default_dims(std::array<int, 3> {2, 3, 4})>> a(ra::Seq<int> {0});
+        auto test = [&](auto dest) { tr.strict().test_eq(transpose(a, dest), reframe(start(a), dest)); };
+        test(ra::ilist_t<0, 1, 2> {});
+        test(ra::ilist_t<1, 2, 0> {});
+        test(ra::ilist_t<2, 0, 1> {});
+        test(ra::ilist_t<2, 1, 0> {});
+        test(ra::ilist_t<1, 0, 2> {});
+        test(ra::ilist_t<0, 2, 1> {});
+    }
     return tr.summary();
 }