Separate ra::iota from ra::tindex

This also separates the concepts of Slice and Iterator. Before, ra::iota was
both; now it's only a Slice. On the other hand, ra::tindex is Iterator but not
Slice.

* ra/expr.hh (Cell): Don't provide data().
  (iter(Slice): Forbid that Slice is also Iterator.
* ra/ply.hh (iota): Is view.
  (ii): Rename to iota, no need for two different names.
* ra/arrays.hh (tindex): New type. Redefine _0, etc. as tindex<0>, etc.
  (reverse): Always return view.
* docs/ra-ra.texi (iota): Update.

Elsewhere replace iota<n> by tindex<n>.

Author: lloda

TODO

@@ -11,17 +11,14 @@ checkbox [C-ct] flip TODO
     - [ ] 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.
-    - [ ] const issues in View vs Container
-      - [ ] conversion to const & op in ViewBig uses reinterpret_const
+    - [ ] conversion to const & op in ViewBig uses reinterpret_const
     - [ ] Small/Big unification
-      - [ ] Unify small and big views
+      - [X] Unify small and big views
       - [ ] Unify small and big containers
     - [ ] Forbid initialization from higher rank
       - Cf 'Initialization of nested types' in the manual.
     - [ ] ambiguity / bad init in nested constructors [ra45]
-    - [ ] ra::at(A, I) needs nested I, so the obvious ra::at(A, [i j]) doesn't work (although
-      view.at([i j]) does). But I would get rid of view.at(i) if ra::at(view, i) worked the same
-      way.
+    - [ ] ra::at(A, I) needs nested I, so the obvious ra::at(A, [i j]) doesn't work.
     - [ ] be namespace clean except for possibly the scalar block in ra.hh. Document exactly what is exported to ::.
     - [ ] bad uses of assert [ra17]
     - [ ] poor shape mismatch report, e.g. [1 2] vs [2] produces 'len[0] is -192...' (magic number for MISS)

bench/bench-at.cc

@@ -110,7 +110,7 @@ int main(int argc, char * * argv)
                    }));
         };
 // at(i) can be a lot slower if i is var rank. FIXME But these are both static rank.
-        auto iotav = ra::ii({100});
+        auto iotav = ra::iota({100});
         static_assert(1==rank(iotav));
         auto iotai = ra::iota(100);
         static_assert(1==rank(iotai));

bench/bench-pack.cc

@@ -20,54 +20,47 @@ int main()
     TestRecorder tr(cout);
     cout.precision(4);
 
-    auto bench = [&tr](auto && f, auto A_, char const * tag, int size, int reps)
-        {
-            using A = decltype(A_);
-            A a({size}, ra::none);
+    auto bench = [&tr](auto && f, auto A_, char const * tag, int size, int reps){
+        using A = decltype(A_);
+        A a({size}, ra::none);
 
-            Benchmark bm { reps, 3 };
-            auto bv = bm.run([&]() { f(a, size); });
-            tr.info(Benchmark::report(bv, size), " ", tag)
-                .test_eq(ra::pack<complex>(ra::iota(size, 0.), size-ra::iota(size, 0.)), a);
-        };
+        Benchmark bm { reps, 3 };
+        auto bv = bm.run([&]() { f(a, size); });
+        tr.info(Benchmark::report(bv, size), " ", tag)
+            .test_eq(ra::pack<complex>(ra::iota(size, 0.), size-ra::iota(size, 0.)), a);
+    };
 
-    auto f_raw = [](auto & a, int size)
-        {
-            real * p = reinterpret_cast<real *>(a.data());
-            for (ra::dim_t i=0; i!=size; ++i, p+=2) {
-                p[0] = i;
-                p[1] = size-i;
-            }
-        };
-    auto f_reim = [](auto & a, int size)
-        {
-            real_part(a) = ra::iota(size);
-            imag_part(a) = size-ra::iota(size);
-        };
-    auto f_collapse = [](auto & a, int size)
-        {
-            auto areim = ra::collapse<real>(a);
-            areim(ra::all, 0) = ra::iota(size);
-            areim(ra::all, 1) = size-ra::iota(size);
-        };
-    auto f_pack = [](auto & a, int size)
-        {
-            a = ra::pack<complex>(ra::iota(size, 0.), size-ra::iota(size, 0.));
-        };
-    auto f_xi = [](auto & a, int size)
-        {
-            a = ra::iota(size, 0.) + xi(size-ra::iota(size, 0.));
-        };
+    auto f_raw = [](auto & a, int size){
+        real * p = reinterpret_cast<real *>(a.data());
+        for (ra::dim_t i=0; i!=size; ++i, p+=2) {
+            p[0] = i;
+            p[1] = size-i;
+        }
+    };
+    auto f_reim = [](auto & a, int size){
+        real_part(a) = ra::iota(size);
+        imag_part(a) = size-ra::iota(size);
+    };
+    auto f_collapse = [](auto & a, int size){
+        auto areim = ra::collapse<real>(a);
+        areim(ra::all, 0) = ra::iota(size);
+        areim(ra::all, 1) = size-ra::iota(size);
+    };
+    auto f_pack = [](auto & a, int size){
+        a = ra::pack<complex>(ra::iota(size, 0.), size-ra::iota(size, 0.));
+    };
+    auto f_xi = [](auto & a, int size){
+        a = ra::iota(size, 0.) + xi(size-ra::iota(size, 0.));
+    };
 
-    auto bench_all = [&](auto A_, int size, int n)
-        {
-            tr.section("size ", size, ", n ", n);
-            bench(f_raw, A_, "raw", size, n);
-            bench(f_reim, A_, "re/im", size, n);
-            bench(f_collapse, A_, "collapse", size, n);
-            bench(f_pack, A_, "pack", size, n);
-            bench(f_xi, A_, "xi", size, n);
-        };
+    auto bench_all = [&](auto A_, int size, int n){
+        tr.section("size ", size, ", n ", n);
+        bench(f_raw, A_, "raw", size, n);
+        bench(f_reim, A_, "re/im", size, n);
+        bench(f_collapse, A_, "collapse", size, n);
+        bench(f_pack, A_, "pack", size, n);
+        bench(f_xi, A_, "xi", size, n);
+    };
 
     bench_all(ra::Big<complex, 1>(), 10, 1000000);
     bench_all(ra::Big<complex, 1>(), 100, 100000);

bench/bench-tensorindex.cc

@@ -19,45 +19,41 @@ int main()
     {
         ra::Big<int, 1> a = {0, 0, 0};
         ra::ply(map([](auto && i) { std::cout << "i: " << i << std::endl; },
-                    a+ra::iota<0>()));
+                    a+ra::tindex<0>));
         ra::ply_ravel(map([](auto && i) { std::cout << "i: " << i << std::endl; },
-                          a+ra::iota<0>()));
+                          a+ra::tindex<0>));
     }
 // rank 2
     {
         ra::Big<int, 2> a = {{0, 0, 0}, {0, 0, 0}};
         ra::ply(map([](auto && i, auto && j) { std::cout << "i: " << i << ", " << j << std::endl; },
-                    a+ra::iota<0>(), a+ra::iota<1>()));
+                    a+ra::tindex<0>, a+ra::tindex<1>));
         ra::ply_ravel(map([](auto && i, auto && j) { std::cout << "i: " << i << ", " << j << std::endl; },
-                          a+ra::iota<0>(), a+ra::iota<1>()));
+                          a+ra::tindex<0>, a+ra::tindex<1>));
     }
 // benchmark
-    auto taking_view =
-        [](TestRecorder & tr, auto && a)
-        {
-            auto fa = [&a]()
-                      {
-                          int c = 0;
-                          ra::ply(ra::map([&c](auto && i, auto && j) { c += 2*i-j; },
-                                          a+ra::iota<0>(), a+ra::iota<1>()));
-                          return c;
-                      };
-            auto fb = [&a]()
-                      {
-                          int c = 0;
-                          ra::ply_ravel(ra::map([&c](auto && i, auto && j) { c += 2*i-j; },
-                                                a+ra::iota<0>(), a+ra::iota<1>()));
-                          return c;
-                      };
+    auto taking_view = [](TestRecorder & tr, auto && a){
+        auto fa = [&a]{
+            int c = 0;
+            ra::ply(ra::map([&c](auto && i, auto && j) { c += 2*i-j; },
+                            a+ra::tindex<0>, a+ra::tindex<1>));
+            return c;
+        };
+        auto fb = [&a]{
+            int c = 0;
+            ra::ply_ravel(ra::map([&c](auto && i, auto && j) { c += 2*i-j; },
+                                  a+ra::tindex<0>, a+ra::tindex<1>));
+            return c;
+        };
 
-            tr.test_eq(499500000, fa());
-            tr.test_eq(499500000, fb());
+        tr.test_eq(499500000, fa());
+        tr.test_eq(499500000, fb());
 
-            auto bench = Benchmark {/* repeats */ 30, /* runs */ 30};
+        auto bench = Benchmark {/* repeats */ 30, /* runs */ 30};
 
-            bench.info("vala").report(std::cout, bench.run(fa), 1e-6);
-            bench.info("valb").report(std::cout, bench.run(fb), 1e-6);
-        };
+        bench.info("vala").report(std::cout, bench.run(fa), 1e-6);
+        bench.info("valb").report(std::cout, bench.run(fb), 1e-6);
+    };
 
     ra::Big<int, 2> const a({1000, 1000}, 0);
     taking_view(tr, a);

docs/index.html

@@ -865,11 +865,19 @@ Besides, when the subscripts @code{i, j, ...} are scalars or integer sequences o
 
 @code{ra::} isn't smart enough to know when an arbitrary expression might be a integer sequence of the appropriate form, so it has a special type for those, the @ref{Sequence views,sequence view}. The following function creates a rank 1 sequence view:
 
+@cindex TensorIndex
 @anchor{x-iota}
-@deffn @w{Special object} iota count [iter:0 [step:1]]
-Create a rank 1 sequence view @code{iter, iter+step, ... iter+step*(count-1)}.
+@anchor{x-tindex}
+@deffn @w{Function} iota [count:@code{UNB} [org:0 [step:1]]]
+@deffnx @w{Function} tindex<k>
+
+These functions are closely related.
+
+@code{iota(count, org, step)} creates a rank-1 @ref{Sequence views,sequence view} [@var{org}, @var{org}+@var{step}, ... @var{org}+@var{step}*(@var{count}-1)]. The default @var{count} results in an unbounded sequence [0, 1, ...].
+
+@code{tindex<k>} creates an iterator over the unbounded sequence [0, 1, ...] at array index @var{k}. The rank of this expression is @var{k}+1.
 
-This can used anywhere an array expression is expected.
+Either can be used anywhere an array expression is expected. @code{iota(...)} is also a view and so it can be subscripted in the usual way.
 
 @example
 @verbatim
@@ -878,34 +886,33 @@ ra::Big<int, 1> a = ra::iota(4, 3 -2);
 @result{} a = @{3, 1, -1, -3@}
 @end example
 
-Here, @code{b} and @code{c} are @code{ViewBig}s (@pxref{Containers and views}).
 @example
 @verbatim
-ra::Big<int, 1> a = {1, 2, 3, 4, 5, 6};
-auto b = a(iota(3));
-auto c = a(iota(3, 3));
+ra::Big<int, 2> a({3, 3}, 10*ra::tindex<0> + ra::tindex<1>)
 @end verbatim
-@result{} a = @{1, 2, 3@}
-@result{} a = @{4, 5, 6@}
+@result{} a = @{@{0, 1, 2@}, @{10, 11, 12@}, @{20, 21, 22@}@}
 @end example
 
-@cindex TensorIndex
-@code{iota()} by itself is an expression of rank 1 and undefined length. It must be used with other terms whose lengths are defined, so that the overall shape of the array expression can be determined. In general, @code{iota<n>()} is an array expression of rank @code{n}+1 that represents the @code{n}-th index of an array expression. This is similar to Blitz++'s @code{TensorIndex}.
-
-@code{ra::} offers the shortcut @code{ra::_0} for @code{ra::iota<0>()}, etc.
+@example
+@verbatim
+auto i = ra::iota(10, 1); // [1 2 3 4 5 6 7 8 9 10]
+auto j = i(ra::iota(3, 2, 2)); // i([2 4 5])
+@end verbatim
+@result{} j = @{3, 5, 7@}
+@end example
 
+@code{j} above is a view, just like @code{b} and @code{c} in the following (@pxref{Containers and views}).
 @example
 @verbatim
-ra::Big<int, 1> v = {1, 2, 3};
-cout << (v - ra::_0) << endl; // { 1-0, 2-1, 3-2 }
-// cout << (ra::_0) << endl; // error: undefined length
-// cout << (v - ra::_1) << endl; // error: undefined length on axis 1
-ra::Big<int, 2> a({3, 2}, 0);
-cout << (a + ra::_0 - ra::_1) << endl; // {{0, -1, -2}, {1, 0, -1}, {2, 1, 0}}
+ra::Big<int, 1> a = {1, 2, 3, 4, 5, 6};
+auto b = a(iota(3));
+auto c = a(iota(3, 3));
 @end verbatim
+@result{} a = @{1, 2, 3@}
+@result{} a = @{4, 5, 6@}
 @end example
 
-When undefined length @code{iota()} is used as a subscript by itself, the result isn't a view. This allows @code{view(iota())} to match with expressions of different lengths, as in the following example.
+However, when unbounded expressions are used as subscripts, the result isn't a view. This allows @code{view(iota())} to match with expressions of different lengths, as in the following example. @c FIXME
 @example
 @verbatim
 ra::Big<int, 1> a = {1, 2, 3, 4, 5, 6};
@@ -916,13 +923,20 @@ cout << (b + a(iota())) << endl; // a(iota()) is not a view
 2 4 6
 @end example
 
-Note the difference between
-@itemize
-@item @code{ra::iota<3>()} —
-an expression of rank 4 and undefined length, representing a linear sequence over the tensor index of axis 3
-@item @code{ra::iota(3)} ≡ @code{ra::iota<0>(3)} —
-an expression of rank 1, representing the sequence @code{0, 1, 2}.
-@end itemize
+Unbounded expressions such as @code{iota()} cannot be traversed by themselves, but must be combined with other terms so that the overall expression is bounded. @code{tindex<k>} can be interpreted as representing the @code{k}-th index of an array expression. This is similar to Blitz++'s @code{TensorIndex}. For the 0-th index, @code{tindex<0>} and @code{iota()} are equivalent.
+
+@example
+@verbatim
+ra::Big<int, 1> v = {1, 2, 3};
+cout << (v - ra::tindex<0>) << endl; // { 1-0, 2-1, 3-2 }
+// cout << (ra::tindex<0>) << endl; // error: undefined length
+// cout << (v - ra::tindex<1>) << endl; // error: undefined length on axis 1
+ra::Big<int, 2> a({3, 2}, 0);
+cout << (a + ra::tindex<0> - ra::tindex<1>) << endl; // {{0, -1, -2}, {1, 0, -1}, {2, 1, 0}}
+@end verbatim
+@end example
+
+@code{ra::} offers the shortcuts @code{ra::_0}, @code{ra::_1}, ... for @code{ra::tindex<0>}, @code{ra::tindex<1>}, ...
 
 @end deffn
 

docs/ra-ra.texi

@@ -59,8 +59,8 @@ int main()
     // shape. Therefore they need to be accompanied by some other expression
     // that does have a shape, or the overall expression is not valid.
     {
-        constexpr auto i = ra::iota<0>();
-        constexpr auto j = ra::iota<1>();
+        constexpr auto i = ra::tindex<0>;
+        constexpr auto j = ra::tindex<1>;
     // That's why you can do
         ra::Big<float, 2> X({3, 4}, i-j);
         cout << "\ni-j: " << X << endl;