ra-ra/test/small-0.C

// -*- mode: c++; coding: utf-8 -*-
/// @file small-0.C
/// @brief Small constructors and assignment.

// (c) Daniel Llorens - 2014, 2016-2017, 2019
// 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
// later version.

// See also small-1.C.

#include <iostream>
#include <iterator>
#include "ra/complex.H"
#include "ra/small.H"
#include "ra/operators.H"
#include "ra/io.H"
#include "ra/big.H"
#include "ra/format.H"
#include "ra/test.H"
#include "ra/mpdebug.H"

using std::cout, std::endl, std::flush;
using complex = std::complex<double>;

struct test_type { int a; };

int main()
{
    TestRecorder tr;
    tr.section("basic");
    {
        tr.test(std::is_standard_layout_v<ra::Small<float, 2>>);
    }
    tr.section("BUG ambiguous case I");
    {
        double U[] = { 1, 2, 3 };
        ra::Small<ra::Big<double, 1>, 1> u = { {U} };
        tr.test_eq(U, u[0]);
        // std::cout << "---------" << std::endl;
        // ra::Small<ra::Big<double, 1>, 1> v = { U }; // BUG [ra45] (Big inits as empty, then assignment fails)
        // std::cout << "---------" << std::endl;
        // cout << v << endl;
    }
    // tr.section("BUG ambiguous case II");
    // {
    //     ra::Small<int, 1, 2> a({ 1, 2 }); // BUG ambiguous [ra46]
    //     // ra::Small<int, 1, 2> a { 1, 2 }; // works as ravel
    //     // ra::Small<int, 1, 2> a {{ 1, 2 }}; // works
    //     // ra::Small<int, 1, 2> a({{ 1, 2 }}); // works
    //     tr.test_eq(1, a(0, 0));
    //     tr.test_eq(2, a(0, 1));
    // }
/*
  Small nested constructors rely on initialized_list so that we can size-check
  the arguments. This check has to be done at run time but I consider that
  preferable to the builtin array syntax which defect errors non-detectable
  (even though excess errors are compile time).

  Still, if we ever want to do that, it's good to know that we can construct
  higher rank builtin array types like this.
*/
    tr.section("= unbraced");
    {
        ra::Small<int, 2> a = {9, 3};
        tr.test_eq(9, a[0]);
        tr.test_eq(3, a[1]);
    }
    tr.section("basic facts about builtin arrays");
    {
        using A0 = double[3];
        using A1 = A0[2];
        using A2 = double[2][3];

        A1 x1 = {{1, 2, 3}, {4, 5, 6}};
        A2 x2 = {{1, 2, 3}, {4, 5, 6}};

        tr.test_eq(2u, std::rank<A1>::value);
        tr.test_eq(2, ra::start(x1).rank());
        tr.test_eq(2u, std::rank<A2>::value);
        tr.test_eq(2, ra::start(x2).rank());

        tr.test_eq(ra::start(x2), x1);
    }
    tr.section("builtin arrays traits I");
    {
        int a[3] = {1, 2, 3};
        tr.test_eq(true, ra::has_traits<decltype(a)>);
        using traits = ra::ra_traits<decltype(a)>;
        tr.test_eq(1, traits::rank(a));
        tr.test_eq(3, traits::size(a));
        tr.test_eq(3, traits::shape(a)[0]);
        tr.test_eq(3, ra::shape(a)[0]);
    }
    tr.section("builtin arrays traits II");
    {
        int a[2][3] = {{1, 2, 3}, {4, 5, 6}};
        tr.test_eq(true, ra::has_traits<decltype(a)>);
        using traits = ra::ra_traits<decltype(a)>;
        tr.test_eq(2, traits::rank(a));
        tr.test_eq(6, traits::size(a));
        tr.test_eq(2, traits::shape(a)[0]);
        tr.test_eq(3, traits::shape(a)[1]);
        tr.test_eq(2, ra::shape(a)[0]);
        tr.test_eq(3, ra::shape(a)[1]);
    }
    tr.section("scalar constructors");
    {
        tr.section("scalar paren unbraced");
        {
            ra::Small<int, 2> a(9);
            tr.test_eq(9, a[0]);
            tr.test_eq(9, a[1]);
        }
        tr.section("scalar op unbraced");
        {
            ra::Small<complex, 2> a = 9.;
            tr.test_eq(9., a[0]);
            tr.test_eq(9., a[1]);
        }
        tr.section("variants I wish didn't work :-/ just checking for regressions");
        {
            {
                ra::Small<int, 2> a({9});
                tr.test_eq(9, a[0]);
                tr.test_eq(9, a[1]);
            }
            {
                ra::Small<int, 2> a {9};
                tr.test_eq(9, a[0]);
                tr.test_eq(9, a[1]);
            }
            {
                ra::Small<complex, 2> a = {9.};
                tr.test_eq(9., a[0]);
                tr.test_eq(9., a[1]);
            }
        }
    }
    tr.section("empty");
    {
        ra::Small<int, 0> x;
        tr.test_eq(0, x.size());
    }
    tr.section("rank 0");
    {
        tr.section("default");
        {
            ra::Small<int> x;
            x = 3;
            tr.test_eq(3, x());
        }
        tr.section("rank 0 paren unbraced");
        {
            ra::Small<int> a(9);
            tr.test_eq(9, a());
        }
        tr.section("rank 0 paren braced");
        {
            ra::Small<int> a({9});
            tr.test_eq(9, a());
        }
        tr.section("rank 0 op unbraced");
        {
            ra::Small<int> a = 9;
            tr.test_eq(9, a());
        }
        tr.section("rank 0 op braced");
        {
            ra::Small<int> a = {9};
            tr.test_eq(9, a());
        }
        tr.section("rank 0 raw braced");
        {
            ra::Small<int> a {9};
            tr.test_eq(9, a());
        }
    }
    tr.section("rank 1");
    {
        tr.section("= unbraced");
        {
            ra::Small<int, 2> a = {9, 3};
            tr.test_eq(9, a[0]);
            tr.test_eq(3, a[1]);
        }
        tr.section("raw unbraced");
        {
            ra::Small<int, 2> a {9, 3};
            tr.test_eq(9, a[0]);
            tr.test_eq(3, a[1]);
        }
        tr.section("paren unbraced");
        {
            ra::Small<int, 2> a({9, 3});
            tr.test_eq(9, a[0]);
            tr.test_eq(3, a[1]);
        }
        tr.section("paren raw");
        {
            ra::Small<int, 2> a(9, 3);
            tr.test_eq(9, a[0]);
            tr.test_eq(3, a[1]);
        }
        tr.section("= scalar init");
        {
            ra::Small<int, 2> a = 9;
            tr.test_eq(9, a[0]);
            tr.test_eq(9, a[1]);
        }
        tr.section("= scalar init with non-ra::scalar type"); // [ra44]
        {
            ra::Small<test_type, 2> a = test_type { 9 };
            tr.test_eq(9, a[0].a);
            tr.test_eq(9, a[1].a);
            a = test_type { 3 };
            tr.test_eq(3, a[0].a);
            tr.test_eq(3, a[1].a);
        }
        // Braced versions used to work but now they don't. This is on purpose.
        // tr.section("= braced");
        // {
        //     ra::Small<int, 2> a = {{9, 3}};
        //     tr.test_eq(9, a[0]);
        //     tr.test_eq(3, a[1]);
        // }
        // tr.section("raw braced");
        // {
        //     ra::Small<int, 2> a {{9, 3}};
        //     tr.test_eq(9, a[0]);
        //     tr.test_eq(3, a[1]);
        // }
        // tr.section("paren braced");
        // {
        //     ra::Small<int, 2> a({{9, 3}});
        //     tr.test_eq(9, a[0]);
        //     tr.test_eq(3, a[1]);
        // }
    }
    tr.section("rank 2");
    {
        tr.section("rank 2 (paren unun)");
        {
            ra::Small<double, 2, 2> a({1, 2}, {3, 4});
            tr.test_eq(1., a(0, 0));
            tr.test_eq(2., a(0, 1));
            tr.test_eq(3., a(1, 0));
            tr.test_eq(4., a(1, 1));
        }
        tr.section("rank 2 (paren un)");
        {
            ra::Small<double, 2, 2> a({{1, 2}, {3, 4}});
            tr.test_eq(1., a(0, 0));
            tr.test_eq(2., a(0, 1));
            tr.test_eq(3., a(1, 0));
            tr.test_eq(4., a(1, 1));
        }
        tr.section("rank 2 (= unbraced)");
        {
            ra::Small<double, 2, 2> a = {{1., 2.}, {3., 4.}};
            tr.test_eq(1., a(0, 0));
            tr.test_eq(2., a(0, 1));
            tr.test_eq(3., a(1, 0));
            tr.test_eq(4., a(1, 1));
        }
        tr.section("rank 2 (raw unbraced) I");
        {
            ra::Small<double, 2, 2> a {{1, 2}, {3, 4}};
            tr.test_eq(1., a(0, 0));
            tr.test_eq(2., a(0, 1));
            tr.test_eq(3., a(1, 0));
            tr.test_eq(4., a(1, 1));
        }
        tr.section("rank 2 (raw unbraced) II");
        {
            ra::Small<double, 2, 3> a {{1, 2, 3}, {4, 5, 6}};
            tr.test_eq(1., a(0, 0));
            tr.test_eq(2., a(0, 1));
            tr.test_eq(3., a(0, 2));
            tr.test_eq(4., a(1, 0));
            tr.test_eq(5., a(1, 1));
            tr.test_eq(6., a(1, 2));
        }
        tr.section("rank 2 (paren raw)");
        {
            ra::Small<double, 2, 2> a({1, 2}, {3, 4});
            tr.test_eq(1., a(0, 0));
            tr.test_eq(2., a(0, 1));
            tr.test_eq(3., a(1, 0));
            tr.test_eq(4., a(1, 1));
        }
        tr.section("size 1, higher rank");
        {
            ra::Small<int, 1, 1> a = {{4}}; // nested
            tr.test_eq(4, a(0, 0));
            ra::Small<int, 1, 1> b = {4}; // ravel
            tr.test_eq(4, b(0, 0));
        }
        tr.section("singular sizes I");
        {
            ra::Small<int, 1, 2> a = {{4, 3}}; // nested. This requires the nested constructor with size(0)==1.
            tr.test_eq(4, a(0, 0));
            tr.test_eq(3, a(0, 1));
            ra::Small<int, 1, 2> b = {4, 3}; // ravel
            tr.test_eq(4, b(0, 0));
            tr.test_eq(3, b(0, 1));
            ra::Small<int, 1, 2> c = {4}; // scalar
            tr.test_eq(4, c(0, 0));
            tr.test_eq(4, c(0, 1));
            // ra::Small<int, 1, 3> d = {4, 2}; // ravel // [ra42] FIXME cannot check ct errors yet
            // tr.test_eq(4, b(0, 0));
            // tr.test_eq(2, b(0, 1));
        }
        // Braced versions used to work but now they don't. This is on purpose.
        // tr.section("rank 2 (paren braced)");
        // {
        //     ra::Small<double, 2, 2> a({{{1, 2}, {3, 4}}});
        //     tr.test_eq(1., a(0, 0));
        //     tr.test_eq(2., a(0, 1));
        //     tr.test_eq(3., a(1, 0));
        //     tr.test_eq(4., a(1, 1));
        // }
        // tr.section("rank 2 (= braced)");
        // {
        //     ra::Small<double, 2, 2> a = {{{1, 2}, {3, 4}}};
        //     tr.test_eq(1., a(0, 0));
        //     tr.test_eq(2., a(0, 1));
        //     tr.test_eq(3., a(1, 0));
        //     tr.test_eq(4., a(1, 1));
        // }
        // tr.section("rank 2 (raw braced)");
        // {
        //     ra::Small<double, 2, 2> a {{{1, 2}, {3, 4}}};
        //     tr.test_eq(1., a(0, 0));
        //     tr.test_eq(2., a(0, 1));
        //     tr.test_eq(3., a(1, 0));
        //     tr.test_eq(4., a(1, 1));
        // }
    }
    tr.section("higher rank, unbraced");
    {
        ra::Small<int, 2, 3, 4, 2> a = {{{{ 1,  2}, { 3,  4}, { 5,  6}, { 7,  8}},
                                         {{ 9, 10}, {11, 12}, {13, 14}, {15, 16}},
                                         {{17, 18}, {19, 20}, {21, 22}, {23, 24}}},
                                        {{{25, 26}, {27, 28}, {29, 30}, {31, 32}},
                                         {{33, 34}, {35, 36}, {37, 38}, {39, 40}},
                                         {{41, 42}, {43, 44}, {45, 46}, {47, 48}}}};
        // FIXME reshape for Small or something! Big/View have these things.
        ra::Small<int, 2, 3, 4, 2> b = 0;
        ra::SmallView<int, mp::int_list<48>, mp::int_list<1>> c(b.data());
        c = ra::iota(48, 1);
        tr.test_eq(b, a);
    }
    tr.section("free constructor");
    {
        ra::Small<int, 2, 2> a = {{1, 2}, ra::iota(2, 33)};
        tr.test_eq(1, a(0, 0));
        tr.test_eq(2, a(0, 1));
        tr.test_eq(33, a(1, 0));
        tr.test_eq(34, a(1, 1));
    }
    tr.section("raveling constructor");
    {
        ra::Small<int, 2, 2> a = {1, 2, 3, 4};
        tr.test_eq(1, a(0, 0));
        tr.test_eq(2, a(0, 1));
        tr.test_eq(3, a(1, 0));
        tr.test_eq(4, a(1, 1));
    }
    tr.section("raveling constructor from iterators");
    {
        int AA[4] = { 1, 2, 3, 4 };
        auto a = ra::ravel_from_iterators<ra::Small<int, 2, 2>>(AA, AA+4);
        tr.test_eq(1, a(0, 0));
        tr.test_eq(2, a(0, 1));
        tr.test_eq(3, a(1, 0));
        tr.test_eq(4, a(1, 1));
    }
    tr.section("nested Small I");
    {
        ra::Small<ra::Small<int, 2>, 2> a = {{1, 2}, {3, 4}};
        tr.test_eq(1, a(0)(0));
        tr.test_eq(2, a(0)(1));
        tr.test_eq(3, a(1)(0));
        tr.test_eq(4, a(1)(1));
    }
    tr.section("nested Small II");
    {
        auto test = [&](auto && a)
                    {
                        tr.test_eq(1, a(0)(0, 0));
                        tr.test_eq(2, a(0)(0, 1));
                        tr.test_eq(3, a(0)(0, 2));
                        tr.test_eq(4, a(0)(1, 0));
                        tr.test_eq(5, a(0)(1, 1));
                        tr.test_eq(6, a(0)(1, 2));
                        tr.test_eq(10, a(1)(0, 0));
                        tr.test_eq(20, a(1)(0, 1));
                        tr.test_eq(30, a(1)(0, 2));
                        tr.test_eq(40, a(1)(1, 0));
                        tr.test_eq(50, a(1)(1, 1));
                        tr.test_eq(60, a(1)(1, 2));
                    };
        using In = ra::Small<int, 2, 3>;
        ra::Small<In, 2> a = {{{1, 2, 3}, {4, 5, 6}}, {{10, 20, 30}, {40, 50, 60}}};
        test(a);
        ra::Small<In, 2> b = {In {{1, 2, 3}, {4, 5, 6}}, In {{10, 20, 30}, {40, 50, 60}}};
        test(b);
        int x[2][3] = {{1, 2, 3}, {4, 5, 6}};
        int y[2][3] = {{10, 20, 30}, {40, 50, 60}};
        ra::Small<In, 2> c = {x, y};
        test(c);
    }
    tr.section("operator=");
    {
        tr.section("operator= rank 1");
        {
            ra::Small<complex, 2> a { 3, 4 };
            a = complex(99.);
            tr.test_eq(99., a[0]);
            tr.test_eq(99., a[1]);
            a = 88.;
            tr.test_eq(88., a[0]);
            tr.test_eq(88., a[1]);
            a += 1.;
            tr.test_eq(89., a[0]);
            tr.test_eq(89., a[1]);
        }
        tr.section("operator= rank 2 unbraced");
        {
            ra::Small<int, 2, 2> a = 0;
            a = {{1, 2}, {3, 4}};
            tr.test_eq(1, a(0, 0));
            tr.test_eq(2, a(0, 1));
            tr.test_eq(3, a(1, 0));
            tr.test_eq(4, a(1, 1));
        }
        // tr.section("operator= rank 2 braced"); // Doesn't work but cannot check ct errors [ra42]
        // {
        //     ra::Small<int, 2, 2> a = 0;
        //     a = {{{1, 2}, {3, 4}}};
        //     tr.test_eq(1, a(0, 0));
        //     tr.test_eq(2, a(0, 1));
        //     tr.test_eq(3, a(1, 0));
        //     tr.test_eq(4, a(1, 1));
        // }
        tr.section("operator= of view into view");
        {
            {
                ra::Small<int, 2, 2> a = {{1, 2}, {3, 4}};
                ra::SmallView<int, mp::int_list<2>, mp::int_list<1>> a0 = a(0);
                ra::SmallView<int, mp::int_list<2>, mp::int_list<1>> a1 = a(1);
                a0 = a1;
                tr.test_eq(ra::Small<int, 2, 2> {{3, 4}, {3, 4}}, a);
            }
            {
                ra::Small<int, 2, 2> a = {{1, 2}, {3, 4}};
                ra::SmallView<int, mp::int_list<2>, mp::int_list<1>> a0 = a(0);
                a0 = a(1);
                tr.test_eq(ra::Small<int, 2, 2> {{3, 4}, {3, 4}}, a);
            }
        }
        tr.section("repeat a test from test/big-0 [ra38]");
        {
            ra::Small<double, 2> A = {1, 2};
            ra::Small<double, 2> X = {0, 0};
            X(ra::all) = A();
            tr.test_eq(ra::start({1, 2}), X);
        }
    }
// These tests should fail at compile time. No way to check them yet [ra42].
    // tr.section("size checks");
    // {
    //     ra::Small<int, 3> a = { 1, 2, 3 };
    //     ra::Small<int, 2> b = { 4, 5 };
    //     ra::Small<int, 3> c = a+b;
    //     cout << c << endl;
    // }
    return tr.summary();
}