Simplify ViewBig conversion constructors

We want to use std::array instead of Small for ViewBig::Dimv, because Small
won't be defined yet for the coming refactored version, and we already have to
deal with non-ra dimv for the var-rank version.

* ra/arrays.hh (ViewBig): As stated.
  (swap): Refactor.
* box/view.cc: ViewSmall/ViewBig refactor sandbox.
* ra/base.hh (VERSION): Bump to 32.

Author: lloda

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']]
+ for example in ['tuple-construct', 'iterator-as-ravel', 'view']]
 
 if not top['skip_summary']:
     atexit.register(lambda: ra.print_summary(GetBuildFailures, 'ra/box'))

ra/arrays.hh

@@ -299,7 +299,7 @@ struct choose_<D, O>
 // Properly ra::.
 // ---------------------
 
-constexpr int VERSION = 31;
+constexpr int VERSION = 32;
 constexpr int ANY = -1944444444; // only static, meaning tbd at runtime
 constexpr int UNB = -1988888888; // unbounded, eg dead axes
 constexpr int MIS = -1922222222; // mismatch, only from common_len

ra/base.hh

@@ -80,7 +80,7 @@ int main()
         ra::Big<int, 2> a ({2, 3}, {0, 1, 2, 3, 4, 5});
         ra::Big<int, 2> b ({2, 3}, {0, 1, 2, 3, 4, 5});
         auto c = transpose(ra::ViewBig<int *, 2>({3, 2}, a.data()), {1, 0});
-        a.dimv = c.dimv;
+        ra::iter(a.dimv) = c.dimv;
         for (int k=0; k!=c.rank(); ++k) {
             std::cout << "CSTRIDE " << k << " " << c.step(k) << std::endl;
             std::cout << "CLEN " << k << " " << c.len(k) << std::endl;

test/big-1.cc

@@ -71,7 +71,7 @@ int main()
         {
             double aa[6] = { 1, 2, 3, 4, 5, 6 };
             aa[0] = 99;
-            ra::ViewBig<double *, 2> a { { {3, 2}, {2, 1}}, aa };
+            ra::ViewBig<double *, 2> a { {{3, 2}, {2, 1}}, aa };
             tr.test_eq(4., a(1, 1));
             tr.test_eq(99., a.data()[0]);
         }

test/ra-0.cc

@@ -15,25 +15,23 @@ using std::cout, std::endl, std::flush, ra::TestRecorder;
 int main()
 {
     TestRecorder tr;
-    auto test =
-        [&](auto & a0, auto & a1, auto & b0, auto & b1)
-        {
-            auto ap = a1.data();
-            auto bp = b1.data();
-            tr.test_eq(a0, a1);
-            tr.test_eq(b0, b1);
-            swap(a1, b1);
-            tr.test_eq(a0, b1);
-            tr.test_eq(b0, a1);
-            tr.test_eq(ra::scalar(ap), ra::scalar(b1.data()));
-            tr.test_eq(ra::scalar(bp), ra::scalar(a1.data()));
-            swap(b1, a1);
-            tr.test_eq(a0, a1);
-            tr.test_eq(b0, b1);
-            tr.test_eq(ra::scalar(ap), ra::scalar(a1.data()));
-            tr.test_eq(ra::scalar(bp), ra::scalar(b1.data()));
-        };
-    tr.section("swap ct and rt");
+    auto test = [&](auto & a0, auto & a1, auto & b0, auto & b1){
+        auto ap = a1.data();
+        auto bp = b1.data();
+        tr.test_eq(a0, a1);
+        tr.test_eq(b0, b1);
+        swap(a1, b1);
+        tr.test_eq(a0, b1);
+        tr.test_eq(b0, a1);
+        tr.test_eq(ra::scalar(ap), ra::scalar(b1.data()));
+        tr.test_eq(ra::scalar(bp), ra::scalar(a1.data()));
+        swap(b1, a1);
+        tr.test_eq(a0, a1);
+        tr.test_eq(b0, b1);
+        tr.test_eq(ra::scalar(ap), ra::scalar(a1.data()));
+        tr.test_eq(ra::scalar(bp), ra::scalar(b1.data()));
+    };
+    tr.section("swap ct and rt. Ranks must be the same.");
     {
         ra::Small<int, 2, 3> a0 = 1 + ra::_0 - ra::_1;
         ra::Big<int, 2> a1 ({2, 3}, 1 + ra::_0 - ra::_1);
@@ -43,7 +41,7 @@ int main()
 
         test(a0, a1, b0, b1);
     }
-    tr.section("swap ct and ct");
+    tr.section("swap ct and ct. Ranks must be the same.");
     {
         ra::Small<int, 2, 3> a0 = 1 + ra::_0 - ra::_1;
         ra::Big<int, 2> a1 ({2, 3}, 1 + ra::_0 - ra::_1);
@@ -53,10 +51,11 @@ int main()
 
         test(a0, a1, b0, b1);
     }
-    tr.section("swap rt and rt");
+    tr.section("swap rt and rt. Ranks need not be the same.");
     {
         ra::Small<int, 2, 3> a0 = 1 + ra::_0 - ra::_1;
         ra::Big<int> a1 ({2, 3}, 1 + ra::_0 - ra::_1);
+
         ra::Small<int, 2, 3, 4> b0 = 1 - ra::_0 + ra::_1 + ra::_2;
         ra::Big<int> b1 ({2, 3, 4}, 1 - ra::_0 + ra::_1 + ra::_2);