Remove value convertibility exclusion from Cell

This was done because the old impl of iota() used to be non-convertible, but
there's no reason to handle this differently from other exprs.

* ra/expr (Cell): As stated.

Author: lloda

TODO

@@ -13,11 +13,6 @@ checkbox [C-ct] flip TODO
       Match isn't even involved. See checks.cc.
     - [ ] const issues in View vs Container
       - [ ] conversion to const & op in ViewBig uses reinterpret_const
-    - [X] ra::Small<real, 3, 3, 3>() benchmark in bench-dot.cc has op 10x worse than indexed
-      - Fixed in ca20c1678bb7aa43ccf6b4fe1b93ee9c742b1630. Yay!
-      - Appears to have regressed in 65076211eeeeecd8623877e3e3b5cc0a87af302c, although by a smaller factor. Bummer.
-      - Looks good in v20 in g++-11, but bad in 12/13. Bummer.
-      - Investigated & resolved in e297ee0561a647065fb5b92880fe0f994340595c ss.
     - [ ] Small/Big unification
     - [ ] Forbid initialization from higher rank
       - Cf 'Initialization of nested types' in the manual.
@@ -32,26 +27,25 @@ checkbox [C-ct] flip TODO
   - [-] Features [0/15]
     - [ ] generalize cat
     - [-] support std::format
-      - [X] basic support
-      - [X] ways to use the formatter without parsing, like ra::format_t { .option = value ... }.
       - [ ] ellipsis feature, e.g. max width/max length.
       - [ ] formatting options for the shape (needed?)
+      - [X] ways to use the formatter without parsing, like ra::format_t { .option = value ... }.
+      - [X] basic support
     - [ ] compatibility with OpenMP, even if only for trivially parallel cases
           The way ply() works atm, with iterators, more or press precludes it.
     - [ ] support expr = braces for any expr, not just views.
     - [ ] make iter work with w/rank.
     - [ ] make iter work with foreign vectors.
     - [ ] Can choose iteration order in plyers. Order is already explicit, just need to expose it.
     - [-] Deduction guides, e.g. ra::Small a = {{1, 2}, {3, 4}} ?! maybe rank 1 first
-      - [X] rank 1 SmallArray <2023-06-23 Fri 13:24> (not very useful)
       - [ ] rank >1 SmallArray
       - [ ] Small
       - [ ] Big
+      - [X] rank 1 SmallArray <2023-06-23 Fri 13:24> (not very useful)
     - [ ] Support ra::len in x in o.len(x).
     - [ ] Shape returns Small not std::array (for static rank expr).
     - [ ] Remove inheritance relationship of Container on ViewBig
-    - [ ] Should be able to turn ravel iterators (e.g. ViewBig::begin()) into array iterators. Ptr()
-      doesn't work for that.
+    - [ ] Should be able to turn ravel iterators (e.g. ViewBig::begin()) into array iterators.
       - This has become more feasible after changing the iterator interface from flat to saveload,
         main obstacle atm seems to be the need to support copy. <2023-11-20 Mon 12:45>
       - One can now create a ravel iterator from an Iterator <2023-11-28 Tue 16:37>
@@ -61,12 +55,12 @@ checkbox [C-ct] flip TODO
       it's just a one time op. Propagating ops down Map into leaf Views (a kind of beating) would
       be better.
     - [-] Magic subscript len
+      - [ ] Optimize iota(len...) + iota(len...)
       - [X] For Big/View in beatable subscripts <2023-07-04 Tue 18:20>
       - [X] For Big/View in unbeatable subscripts <2023-07-05 Wed 12:34>
       - [X] For Small/ViewSmall
         - [X] Scalar / unbeatable <2023-08-04 Fri 14:18>
         - [X] iota. But iota args need to integral constants for this to work.
-      - [ ] Optimize iota(len...) + iota(len...)
   - [-] Performance [0/2]
     - [ ] bench/bench-stencil* is weird.
     - [ ] Bigd cases in bench-at.
@@ -76,7 +70,7 @@ checkbox [C-ct] flip TODO
     - [X] Support RA_USE_BLAS with cmake (mac) <2018-12-07 Fri 16:33>
     - [X] TestRecorder.test_eq with mismatched shapes aborts. Should just fail the test. <2023-07-10 Mon 13:14>
       - We have had agree() for a while.
-    - [ ] Make cmake tests respect dependences and able to be run independently.
+    - [ ] Make cmake tests respect dependencies and able to be run independently.
     - [ ] Test for expected compilation errors (static_assert, etc) [ra42].
       - One idea (libc++?) is to fork() and check that child breaks.
   - [ ] Documentation [0/3]
@@ -225,3 +219,8 @@ Some of these aren't bugs in the sense that I expect to solve them, but more lik
     - <2025-07-24 Thu 11:35> was caused by auto && x constructor interfereing.
       Fixed in 85653fd786c78e339f730699021ebdac39877012
   - [X] Merge Ptr and Iota. Why need more than one rank 1 Iterator adaptor.
+  - [X] ra::Small<real, 3, 3, 3>() benchmark in bench-dot.cc has op 10x worse than indexed
+    - Fixed in ca20c1678bb7aa43ccf6b4fe1b93ee9c742b1630. Yay!
+    - Appears to have regressed in 65076211eeeeecd8623877e3e3b5cc0a87af302c, although by a smaller factor. Bummer.
+    - Looks good in v20 in g++-11, but bad in 12/13. Bummer.
+    - Investigated & resolved in e297ee0561a647065fb5b92880fe0f994340595c ss.

box/SConstruct

@@ -50,7 +50,7 @@ env.Prepend(CPPPATH=['..', '.'],
             LINKFLAGS=raflags['LINKFLAGS'])
 
 [ra.to_test_ra(env, variant_dir)(example)
- for example in ['tuple-construct', 'iterator-as-ravel', 'cellptr']]
+ for example in ['tuple-construct', 'iterator-as-ravel']]
 
 if not top['skip_summary']:
     atexit.register(lambda: ra.print_summary(GetBuildFailures, 'ra/box'))

ra/expr.hh

@@ -319,17 +319,16 @@ struct Cell: public std::conditional_t<is_constant<Dimv>, CellSmall<P, Dimv, Cr>
     using Base::Base, Base::cellr, Base::framer, Base::c, Base::step, Base::len, Base::len_s, Base::rank;
     using View = decltype(std::declval<Base>().c);
     static_assert((cellr>=0 || cellr==ANY) && (framer>=0 || framer==ANY), "Bad cell/frame ranks.");
-    constexpr auto data() const { return c.cp; }
     RA_ASSIGNOPS_ITER(Cell)
-// FIXME only for the sake of iota(), which needs to be both iterator and slice.
+// for the sake of iota(), which needs to be both iterator and slice. FIXME make iota() View not Cell.
     template <rank_t c=0> constexpr auto iter() const requires (0==cellr && 1==framer) { static_assert(0==c); return *this; }
+    constexpr auto data() const { return c.cp; }
     constexpr void adv(rank_t k, dim_t d) { mov(step(k)*d); }
     constexpr decltype(*c.cp) at(auto const & i) const requires (0==cellr) { return *indexer(*this, c.cp, ra::iter(i)); }
     constexpr View at(auto const & i) const requires (0!=cellr) { View d(c); d.cp=indexer(*this, d.cp, ra::iter(i)); return d; }
     constexpr decltype(*c.cp) operator*() const requires (0==cellr) { return *(c.cp); }
     constexpr View const & operator*() const requires (0!=cellr) { return c; }
-    constexpr static bool static_1 = framer>=0 && std::apply([](auto ... i){ return ((1==len_s(i)) && ...); }, mp::iota<(framer<0)?0:framer> {});
-    constexpr operator decltype(*c.cp) () const requires (0==cellr && static_1) /* [ra45 */ { return to_scalar(*this); }
+    constexpr operator decltype(*c.cp) () const { return to_scalar(*this); } /* [ra45] */
     constexpr auto save() const { return c.cp; }
     constexpr void load(P p) { c.cp=p; }
 #pragma GCC diagnostic push
@@ -348,25 +347,20 @@ constexpr auto
 ptr(P && p, N && n=N {}, S && s=S(maybe_step<S>))
 {
     if constexpr (std::ranges::bidirectional_range<std::remove_reference_t<P>>) {
-        static_assert(std::is_same_v<ic_t<dim_t(UNB)>, N>, "Object has own length.");
-        static_assert(std::is_same_v<ic_t<dim_t(1)>, S>, "No step with deduced size.");
-        if constexpr (ANY==size_s(p)) {
-            return ptr(std::begin(RA_FW(p)), std::ssize(p), RA_FW(s));
-        } else {
-            return ptr(std::begin(RA_FW(p)), ic<size_s(p)>, RA_FW(s));
-        }
+        static_assert(std::is_same_v<ic_t<dim_t(UNB)>, N>, "Conflict with own length.");
+        static_assert(std::is_same_v<ic_t<dim_t(1)>, S>, "Deduced size means unit step.");
+        return ptr(std::begin(RA_FW(p)), [&p](){ if constexpr (ANY==size_s(p)) return ra::size(p); else return ic<size_s(p)>; }(), RA_FW(s));
     } else {
         if constexpr (std::is_integral_v<N>) { RA_CK(n>=0, "Bad Ptr length ", n, "."); }
-        using Dim = ra::SDim<sarg<N>, sarg<S>>;
-        return Ptr<std::decay_t<P>, sarg<N>, sarg<S>> { p, {Dim {.len=RA_FW(n), .step=RA_FW(s) }}};
+        return Ptr<std::decay_t<P>, sarg<N>, sarg<S>> { p, {ra::SDim<sarg<N>, sarg<S>> {.len=RA_FW(n), .step=RA_FW(s) }}};
     }
 }
 
 template <class I, class N, class S, class K=ic_t<dim_t(0)>>
 constexpr auto
 reverse(Ptr<Seq<I>, N, S> const & i, K k = {})
 {
-    static_assert(UNB!=i.len_s(0), "Bad arguments to reverse(iota).");
+    static_assert(UNB!=i.len_s(0), "Bad arguments to reverse.");
     return ptr(Seq { i.data().i+(i.dimv[0].len-1)*i.dimv[0].step }, i.dimv[0].len, csub(ic<0>, i.dimv[0].step));
 }
 

ra/ply.hh

@@ -538,7 +538,7 @@ fromb(auto pl, auto ds, auto && bv, int bk, auto && a, int ak)
 #pragma GCC diagnostic push // gcc14/15 -DRA_CHECK=0 --no-sanitize -O2 -O3 [ra03]
 #pragma GCC diagnostic warning "-Warray-bounds"
 #pragma GCC diagnostic warning "-Wstringop-overflow"
-            bv[bk] = { a.dimv[ak].len, a.dimv[ak].step }; // support Ptr
+            bv[bk] = { a.dimv[ak].len, a.dimv[ak].step };
 #pragma GCC diagnostic pop
         }
     }

test/SConstruct

@@ -52,7 +52,7 @@ env.Prepend(CPPPATH=['..', '.'],
 tester = ra.to_test_ra(env, variant_dir)
 
 [tester(test)
- for test in ['at', 'bench', 'big-0', 'big-1', 'bug83', 'bug10', 'cellrank', 'checks', 'compatibility',
+ for test in ['at', 'bench', 'big-0', 'big-1', 'bug83', 'bug10', 'cellptr', 'cellrank', 'checks', 'compatibility',
               'concrete', 'const', 'constexpr', 'dual', 'early', 'explode-0', 'foreign', 'frame-new',
               'frame-old', 'fromb', 'fromu', 'genfrom', 'headers', 'io', 'iota', 'iterator-small', 'len',
               'list9', 'macros', 'mem-fn', 'ndebug', 'nested-0', 'operators', 'optimize',

test/big-0.cc

@@ -78,7 +78,7 @@ int main(int argc, char * * argv)
         static_assert(!ctest3<int>);
         static_assert(!ctest4<int>);
 
-        // FIXME these errors depend on  static_assert so cannot be checked with requires.
+// FIXME these errors depend on static_assert so cannot be checked with requires.
         // ra::Big<T, 2> {3, 4}; // Invalid shape for rank
         // ra::Big<int, 2> (2, ra::none); // shape arg must have rank 1 for array rank>1
         // ra::Big<T, 2> {1, 2, 3, 4, 5, 6}; // bad deduced shape from content arg
@@ -198,13 +198,12 @@ int main(int argc, char * * argv)
         ra::Small<ra::Big<int, 1>, 1> d = { {1, 2, 3} }; // ok
         tr.test_eq(ra::iota(3, 1), d(0));
 
-// requires that x NOT be convertible to int,  but expressions generally are convertible to their val type.
-// his is hacked away in Cell's conversion operator. FIXME probably not worth it.
-        auto x = ra::iota(3, 1);
-        ra::Small<ra::Big<int, 1>, 1> f = { {x} }; // ok; broken with { x }
-        tr.test_eq(ra::iota(3, 1), f(0));
+// these fail because x/w is convertible to int. This used not to be the case for old Ptr / iota (so the 1st one worked), but if anything, it is the second that shouldn't be convertible, because the size is static and we exclude size_s!=1 from convertibility (maybe FIXME).
+
+        // auto x = ra::iota(3, 1);
+        // ra::Small<ra::Big<int, 1>, 1> f = { {x} }; // broken with { x }, rt error with { {x} }
+        // tr.test_eq(ra::iota(3, 1), f(0));
 
-// fails for the same reason.
         // ra::Small<int, 3> w = { 1, 2, 3 };
         // ra::Small<ra::Big<int, 1>, 1> e = { {w} }; // broken with { w }, ct error with { {w} }
         // tr.test_eq(ra::iota(3, 1), e(0));

test/cellptr.cc

@@ -1,7 +1,7 @@
 // -*- mode: c++; coding: utf-8 -*-
-// ra-ra/box - Special Dimv to let Cell<> replace Ptr
+// ra-ra/box - Replacement sandbox of Oldptr (old ptr/iota) by Cell (current)
 
-// (c) Daniel Llorens - 2025
+// (c) Daniel Llorens - 2025-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
@@ -219,20 +219,5 @@ int main()
         tr.test(ra::Slice<decltype(ra::iota2(10))>);
         tr.test(ra::Slice<decltype(ra::iota3(10))>);
     }
-// 1st goes to constexpr SmallArray(T const & t) { std::ranges::fill(cp, t); }, the other idk :-/
-    tr.section("regression from test/big-0");
-    {
-        auto x = ra::iota1(3, 1);
-        cout << "conv1 " << std::is_convertible_v<decltype(x), int> << endl;
-        ra::Small<ra::Big<int, 1>, 1> f = { {x} }; // ok; broken with { x }
-        tr.test_eq(ra::iota(3, 1), f(0));
-    }
-    {
-        auto x = ra::iota3(3, 1);
-        cout << "conv1 " << std::is_convertible_v<decltype(x), int> << endl;
-        cout << "static_1 " << decltype(x)::static_1 << endl;
-        ra::Small<ra::Big<int, 1>, 1> f = { {x} }; // ok; broken with { x }
-        tr.test_eq(ra::iota(3, 1), f(0));
-    }
     return tr.summary();
 }

test/iota.cc

@@ -74,8 +74,8 @@ int main()
     {
         tr.test_eq(sizeof(ra::iota().data()), sizeof(ra::dim_t));
         tr.test_eq(sizeof(ra::iota(4, 0, 2).data()), sizeof(0));
-        tr.info("not true when Ptr is slice").skip().test_eq(sizeof(ra::iota().data()), sizeof(ra::iota()));
-        tr.info("not true when Ptr is slice").skip().test_eq(sizeof(ra::iota().data()), sizeof(ra::iota(ra::dim_c<4> {})));
+        tr.info("not when Ptr is Cell").skip().test_eq(sizeof(ra::iota().data()), sizeof(ra::iota()));
+        tr.info("not when Ptr is Cell").skip().test_eq(sizeof(ra::iota().data()), sizeof(ra::iota(ra::dim_c<4> {})));
 // sizeof might still be > sizeof(i) + sizeof(n) because of alignment
         tr.test_eq(1, decltype(ra::iota(4).dimv[0].step)::value);
         tr.test_eq(sizeof(ra::iota(4, 0, 2)), sizeof(ra::iota(4, 0, 2).data()) + sizeof(ra::iota(4, 0, 2).dimv[0].len) + sizeof(ra::iota(4, 0, 2).dimv[0].step));