Clear spurious (?) warning in filldimv()

* ra/expr.hh (filldimv): Resize, take Iterator, manually fill dimv[..].len.
  (default_dims): Adapt user.
  (Ptr::mov, Cell::mov): Remove aggressive-optimizations diagnostic override,
  caused by Seq<int>.
* ra/big.hh: Adapt users.
* test/wrank.c, test/small-1.cc: Don't use Seq<int>.
* ra/ra.hh: Add binary op %.

Author: lloda

TODO

@@ -7,6 +7,7 @@ checkbox [C-ct] flip TODO
 
 * TODO [1/7]
   - [-] Bugs [5/16]
+    - [ ] We shouldn't need ra::iota(3, ra::dim_t(4)) to get iota to use Seq<dim_t> instead of Seq<int>.
     - [ ] Fix reduction-1.cc: "real_part(iter<1>(m)) = real_part(iter<1>(c))"
     - [ ] Invalid expressions that aren't caught by Match, either bc it makes assumptions, or bc
       Match isn't even involved. See checks.cc.

examples/maxwell.cc

@@ -63,17 +63,16 @@ int main()
     auto time_A = Benchmark::clock::now()-t0;
 
 // FIXME should try to traverse the array once, e.g. explode() = pack(...), but we need to wrap around boundaries.
-    auto diff = [&DA, &A, &delta](auto k_, real factor)
-        {
-            constexpr int k = k_;
-            const int o = DA.len(k);
-            if (o>=2) {
-                DA(HH<k>, iota(o-2, 1), HH<4-k>, k) = (A(HH<k>, iota(o-2, 2)) - A(HH<k>, iota(o-2, 0)));
-                DA(HH<k>, 0, HH<4-k>, k) = (A(HH<k>, 1) - A(HH<k>, o-1));
-                DA(HH<k>, o-1, HH<4-k>, k) = (A(HH<k>, 0) - A(HH<k>, o-2));
-                DA(HH<5>, k) *= factor;
-            }
-        };
+    auto diff = [&DA, &A, &delta](auto k_, real factor) {
+        constexpr int k = k_;
+        const int o = DA.len(k);
+        if (o>=2) {
+            DA(HH<k>, iota(o-2, 1), HH<4-k>, k) = (A(HH<k>, iota(o-2, 2)) - A(HH<k>, iota(o-2, 0)));
+            DA(HH<k>, 0, HH<4-k>, k) = (A(HH<k>, 1) - A(HH<k>, o-1));
+            DA(HH<k>, o-1, HH<4-k>, k) = (A(HH<k>, 0) - A(HH<k>, o-2));
+            DA(HH<5>, k) *= factor;
+        }
+    };
 
     t0 = Benchmark::clock::now();
     diff(ic<0>, +1/(2*delta));

ra/big.hh

@@ -45,17 +45,6 @@ braces_shape(braces<T, r> const & l)
     return [&l]<int ... i>(ilist_t<i ...>){ return std::array { braces_len<i, T, r>(l) ... }; }(mp::iota<r>{});
 }
 
-constexpr void
-resize(auto & a, dim_t s)
-{
-    if constexpr (ANY==size_s(a)) {
-        RA_CK(s>=0, "Bad resize ", s, ".");
-        a.resize(s);
-    } else {
-        RA_CK(s==start(a).len(0) || UNB==s, "Bad resize ", s, ", need ", start(a).len(0), ".");
-    }
-}
-
 // FIXME avoid duplicating cp, dimv from Container without being parent. Parameterize on Dimv, like Cell.
 // FIXME constructor checks (lens>=0, steps inside, etc.).
 template <class P, rank_t RANK>
@@ -81,11 +70,11 @@ struct ViewBig
     constexpr ViewBig(Dimv const & dimv_, P cp_): dimv(dimv_), cp(cp_) {} // [ra36]
     constexpr ViewBig(auto const & s, P cp_): cp(cp_)
     {
-        ra::resize(dimv, ra::size(s)); // [ra37]
         if constexpr (std::is_convertible_v<value_t<decltype(s)>, Dim>) {
+            ra::resize(dimv, ra::size(s)); // [ra37]
             start(dimv) = s;
         } else {
-            filldimv(s, dimv);
+            filldimv(start(s), dimv);
         }
     }
     constexpr ViewBig(std::initializer_list<dim_t> s, P cp_): ViewBig(start(s), cp_) {}
@@ -228,8 +217,7 @@ struct Container: public ViewBig<typename storage_traits<Store>::T *, RANK>
         static_assert(!std::is_convertible_v<value_t<decltype(s)>, Dim>);
         RA_CK(1==ra::rank(s), "Rank mismatch for init shape.");
         static_assert(ANY==RANK || ANY==size_s(s) || RANK==size_s(s) || UNB==size_s(s), "Bad shape for rank.");
-        ra::resize(dimv, ra::size(s)); // [ra37]
-        store = storage_traits<Store>::create(filldimv(s, dimv));
+        store = storage_traits<Store>::create(filldimv(start(s), dimv));
         cp = storage_traits<Store>::data(store);
     }
     constexpr void init(dim_t s) { init(std::array {s}); } // scalar allowed as shape if rank is 1.
@@ -287,8 +275,7 @@ struct Container: public ViewBig<typename storage_traits<Store>::T *, RANK>
     }
     constexpr void resize(auto const & s) requires (1==rank_s(s))
     {
-        ra::resize(dimv, 0==rank_s(s) ? 1 : ra::size(s));
-        store.resize(filldimv(s, dimv)); cp = store.data();
+        store.resize(filldimv(start(s), dimv)); cp = store.data();
     }
 // template + RA_FW wouldn't work for push_back(brace-enclosed-list).
     constexpr void push_back(T && t)
@@ -470,7 +457,7 @@ reshape(ViewBig<P, RANK> const & a, S && sb_)
         if (sa[a.rank()-i-1]!=sb[b.rank()-i-1]) {
             RA_CK(is_c_order(a, false) && la>=lb, "Reshape with copy not implemented.");
 // FIXME ViewBig(SS const & s, T * p). Cf [ra37].
-            filldimv(sb, b.dimv);
+            filldimv(start(sb), b.dimv);
             for (int j=0; j!=b.rank(); ++j) {
                 b.dimv[j].step *= a.step(a.rank()-1);
             }

ra/expr.hh

@@ -105,7 +105,7 @@ maybe_len(auto const & v, K k) { if constexpr (is_constant<K> && (ANY!=v.len_s(k
 
 // Sequence iterator.
 
-template <class I>
+template <class I=dim_t>
 struct Seq
 {
     I i;
@@ -232,25 +232,33 @@ struct Dim { dim_t len, step; };
 inline std::ostream &
 operator<<(std::ostream & o, Dim const & dim) { std::print(o, "[Dim {} {}]", dim.len, dim.step); return o; }
 
+constexpr void
+resize(auto & a, dim_t s)
+{
+    if constexpr (ANY==size_s(a)) {
+        RA_CK(s>=0, "Bad resize ", s, ".");
+        a.resize(s);
+    } else {
+        RA_CK(s==start(a).len(0) || UNB==s, "Bad resize ", s, ", need ", start(a).len(0), ".");
+    }
+}
+
 constexpr dim_t
-filldimv(auto const & shape, auto & dimv)
+filldimv(Iterator auto && p, auto & dimv)
 {
-    map(&Dim::len, dimv) = shape;
+    ra::resize(dimv, 0==rank_s(p) ? 1 : ra::size(p)); // [ra37]
+    for (rank_t k=0; k<ra::size(dimv); ++k, p.mov(p.step(0))) { dimv[k].len = *p; }
     dim_t s = 1;
     for (int k=ra::size(dimv); --k>=0;) {
         dimv[k].step = s;
         RA_CK(dimv[k].len>=0, "Bad len[", k, "] ", dimv[k].len, ".");
-// gcc 14.2, no warning with sanitizers
-#pragma GCC diagnostic push
-#pragma GCC diagnostic warning "-Wmaybe-uninitialized"
         s *= dimv[k].len;
-#pragma GCC diagnostic pop
     }
     return s;
 }
 
 consteval auto
-default_dims(auto const & lv) { std::array<Dim, ra::size(lv)> dv; filldimv(lv, dv); return dv; };
+default_dims(auto const & lv) { std::array<Dim, ra::size(lv)> dv; filldimv(start(lv), dv); return dv; };
 
 constexpr rank_t rank_sum(rank_t a, rank_t b) { return ANY==a || ANY==b ? ANY : a+b; }
 constexpr rank_t rank_diff(rank_t a, rank_t b) { return ANY==a || ANY==b ? ANY : a-b; }
@@ -325,10 +333,7 @@ struct Cell: public std::conditional_t<is_constant<Dimv>, CellSmall<P, Dimv, Spe
     constexpr operator decltype(*c.cp) () const { return to_scalar(*this); }
     constexpr auto save() const { return c.cp; }
     constexpr void load(P p) { c.cp=p; }
-#pragma GCC diagnostic push
-#pragma GCC diagnostic warning "-Waggressive-loop-optimizations" // gcc14.3/15.1 -O3 only
     constexpr void mov(dim_t d) { std::ranges::advance(c.cp, d); }
-#pragma GCC diagnostic pop
 };
 
 // rank 1 special case for fovs or iota. FIXME make Ptr a Slice with iter() -> Cell.
@@ -365,10 +370,7 @@ struct Ptr final
     constexpr decltype(*cp) operator*() const { return *cp; }
     constexpr auto save() const { return cp; }
     constexpr void load(P p) { cp=p; }
-#pragma GCC diagnostic push
-#pragma GCC diagnostic warning "-Waggressive-loop-optimizations" // gcc14.3/15.1 -O3 only
     constexpr void mov(dim_t d) { std::ranges::advance(cp, d); }
-#pragma GCC diagnostic pop
 };
 
 template <class X> using sarg = std::conditional_t<is_constant<std::decay_t<X>> || is_scalar<X>, std::decay_t<X>, X>;
@@ -496,9 +498,10 @@ reframe(A && a, Dest)
     }
 }
 
+// I != dim_t may warn "-Waggressive-loop-optimizations" in std::advance(i, ...) in gcc14/15.1 -O3
 template <int w=0, class I=dim_t, class N=ic_t<dim_t(UNB)>, class S=ic_t<dim_t(1)>>
 constexpr auto
-iota(N && n=N {}, I && i=0, S && s=S(maybe_step<S>))
+iota(N && n=N {}, I && i=dim_t(0), S && s=S(maybe_step<S>))
 {
     return reframe(Ptr<Seq<sarg<I>>, sarg<N>, sarg<S>> { {RA_FW(i)}, RA_FW(n), RA_FW(s) }, ilist_t<w> {});
 }

ra/ra.hh

@@ -223,6 +223,7 @@ DEF_NAMED_BINARY_OP(<, std::less<>)          DEF_NAMED_BINARY_OP(>=, std::greate
 DEF_NAMED_BINARY_OP(<=, std::less_equal<>)   DEF_NAMED_BINARY_OP(!=, std::not_equal_to<>)
 DEF_NAMED_BINARY_OP(|, std::bit_or<>)        DEF_NAMED_BINARY_OP(&, std::bit_and<>)
 DEF_NAMED_BINARY_OP(^, std::bit_xor<>)       DEF_NAMED_BINARY_OP(<=>, std::compare_three_way)
+DEF_NAMED_BINARY_OP(%, std::modulus<>)
 #undef DEF_NAMED_BINARY_OP
 
 // FIXME address sanitizer complains in bench-optimize.cc if we use std::identity. Maybe false positive

ra/small.hh

@@ -156,12 +156,12 @@ fromb(auto pl, auto ds, auto && bv, int bk, auto && a, int ak)
 {
     if constexpr (dobv) {
 #pragma GCC diagnostic push
-#pragma GCC diagnostic warning "-Waggressive-loop-optimizations" // gcc14.3/15.2 -DRA_CHECK=0 -O3
+#pragma GCC diagnostic warning "-Waggressive-loop-optimizations" // gcc14/15.2 -DRA_CHECK=0 -O3
         for (; ak<ra::rank(a); ++ak, ++bk) {
 #pragma GCC diagnostic pop
 #pragma GCC diagnostic push
-#pragma GCC diagnostic warning "-Warray-bounds" // gcc14.3/15.2 --no-sanitize -O2 -O3
-#pragma GCC diagnostic warning "-Wstringop-overflow" // gcc14.3/15.2 --no-sanitize -O2 -O3
+#pragma GCC diagnostic warning "-Warray-bounds" // gcc14/15.2 --no-sanitize -O2 -O3
+#pragma GCC diagnostic warning "-Wstringop-overflow" // gcc14/15.2 --no-sanitize -O2 -O3
             bv[bk] = a.dimv[ak];
 #pragma GCC diagnostic pop
         }
@@ -426,13 +426,13 @@ struct ViewSmall
 // T not is_scalar [ra44]
     constexpr ViewSmall const & operator=(T const & t) const { start(*this)=ra::scalar(t); return *this; }
 // cf RA_ASSIGNOPS_ITER [ra38] [ra34]
-    ViewSmall const & operator=(ViewSmall const & x) const { start(*this) = x; return *this; }
+    ViewSmall const & operator=(ViewSmall const & x) const { start(*this)=x; return *this; }
 #define ASSIGNOPS(OP)                                                   \
     constexpr ViewSmall const & operator OP(Iterator auto && x) const { start(*this) OP RA_FW(x); return *this; } \
     constexpr ViewSmall const & operator OP(auto const & x) const { start(*this) OP x; return *this; }
     FOR_EACH(ASSIGNOPS, =, *=, +=, -=, /=)
 #undef ASSIGNOPS
-    template <int s, int o=0> constexpr auto as() const { return from(*this, ra::iota(ra::ic<s>, o)); }
+    template <dim_t s, dim_t o=0> constexpr auto as() const { return from(*this, ra::iota(ic<s>, o)); }
     template <rank_t c=0> constexpr auto iter() const { return Cell<P, ic_t<dimv>, ic_t<c>>(cp); }
     constexpr auto iter(rank_t c) const { return Cell<P, decltype(dimv) const &, dim_t>(cp, dimv, c); }
     constexpr auto begin() const { if constexpr (is_c_order_dimv(dimv)) return cp; else return STLIterator(iter()); }
@@ -503,8 +503,8 @@ SmallArray<T, Dimv, std::tuple<nested_args ...>>
     {
         view() = { x ... };
     }
-    constexpr SmallArray(auto const & x) { view() = x; }
-    constexpr SmallArray(Iterator auto && x) { view() = RA_FW(x); }
+    constexpr SmallArray(auto const & x) { view()=x; }
+    constexpr SmallArray(Iterator auto && x) { view()=RA_FW(x); }
 #define ASSIGNOPS(OP)                                                   \
     constexpr SmallArray & operator OP(auto const & x) { view() OP x; return *this; } \
     constexpr SmallArray & operator OP(Iterator auto && x) { view() OP RA_FW(x); return *this; }

test/iota.cc

@@ -116,5 +116,10 @@ int main()
         tr.test_eq(-2, j.s);
         tr.strict().test_eq(ra::start({-1, -3, -5}), j);
     }
+    tr.section("truncated sequence");
+    {
+        auto i = ra::ii({7, 7, 7}, uint8_t(0));
+        tr.strict().test_eq(ra::ii({7, 7, 7}) % 256, i);
+    }
     return tr.summary();
 }

test/small-1.cc

@@ -461,7 +461,7 @@ int main()
     }
     tr.section("ViewSmall of Seq");
     {
-        ra::ViewSmall<ra::Seq<int>, ra::ic_t<std::array {ra::Dim {3, 2}, ra::Dim {2, 1}}>> a(ra::Seq {1});
+        ra::ViewSmall<ra::Seq<>, ra::ic_t<std::array {ra::Dim {3, 2}, ra::Dim {2, 1}}>> a(ra::Seq<> {1});
         std::println(cout, "{:c:2}\n", transpose(a));
         tr.test_eq(a, 1+ra::Small<int, 3, 2> {{0, 1}, {2, 3}, {4, 5}});
     }

test/wrank.cc

@@ -355,7 +355,7 @@ int main()
     }
     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});
+        ra::ViewSmall<ra::Seq<>, ra::ic_t<ra::default_dims(std::array<int, 3> {2, 3, 4})>> a(ra::Seq<> {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> {});