eschnett/cactusamrex - Change 2CPXGSD5DDJJQ3LXW5LEW5UJYAQYX3ISVCRIMGDQJ5IQYYPCJNEAC

CarpetX: Add self-tests for C++ list initialization

Created by Erik Schnetter on January 23, 2020

2CPXGSD5DDJJQ3LXW5LEW5UJYAQYX3ISVCRIMGDQJ5IQYYPCJNEAC

Dependencies

In channels

main

master

Change contents

Insertion in CarpetX/src/loop.hxx at line 28 [5.5481]

[3.8939]

[4.29]


// TODO: This is broken (at least on MacOS, with gcc 9.2, with -O0).

Replacement in CarpetX/src/loop.hxx at line 31 [5.5481]

B:BD[4.30] → [4.30:90]

B:BD[4.90] → [2.0:33]

∅:D[2.33] → [4.90:295]

B:BD[4.90] → [4.90:295]

namespace {
template <typename T, size_t N, typename... Ts>
/*CCTK_ATTRIBUTE_ALWAYS_INLINE*/
constexpr enable_if_t<(sizeof...(Ts) == N), array<T, N> >
array_from_initializer_list(const T *const beg, const T *const end,
                            const Ts &... xs) {
  return array<T, N>{xs...};
}

[4.30]

[4.295]

// namespace {
// template <typename T, size_t N, typename... Ts>
// /*CCTK_ATTRIBUTE_ALWAYS_INLINE*/
// constexpr enable_if_t<(sizeof...(Ts) == N), array<T, N> >
// array_from_initializer_list(const T *const beg, const T *const end,
//                             const Ts &... xs) {
//   return array<T, N>{xs...};
// }
//
// template <typename T, size_t N, typename... Ts>
// /*CCTK_ATTRIBUTE_ALWAYS_INLINE*/
// constexpr enable_if_t<(sizeof...(Ts) < N), array<T, N> >
// array_from_initializer_list(const T *const beg, const T *const end,
//                             const Ts &... xs) {
//   return array_from_initializer_list<T, N>(beg + 1, end, xs...,
//                                            beg < end ? *beg : T{});
// }
// } // namespace
//
// template <typename T, size_t N>
// /*CCTK_ATTRIBUTE_ALWAYS_INLINE*/ constexpr array<T, N>
// array_from_initializer_list(initializer_list<T> l) {
//   return array_from_initializer_list<T, N>(l.begin(), l.end());
// }

Replacement in CarpetX/src/loop.hxx at line 56 [5.5481]

B:BD[4.296] → [4.296:344]

B:BD[4.344] → [2.34:67]

∅:D[2.67] → [4.344:649]

B:BD[4.344] → [4.344:649]

template <typename T, size_t N, typename... Ts>
/*CCTK_ATTRIBUTE_ALWAYS_INLINE*/
constexpr enable_if_t<(sizeof...(Ts) < N), array<T, N> >
array_from_initializer_list(const T *const beg, const T *const end,
                            const Ts &... xs) {
  return array_from_initializer_list<T, N>(beg + 1, end, xs...,
                                           beg < end ? *beg : T{});

[4.296]

[4.649]

// namespace {
// template <typename T, size_t N, typename... Ts>
// /*CCTK_ATTRIBUTE_ALWAYS_INLINE*/
// constexpr enable_if_t<(sizeof...(Ts) == N), array<T, N> >
// array_from_initializer_list(const T *const beg, const T *const end,
//                             const Ts &... xs) {
//   return array<T, N>{xs...};
// }
// template <typename T, size_t N, typename... Ts>
// /*CCTK_ATTRIBUTE_ALWAYS_INLINE*/
// constexpr enable_if_t<(sizeof...(Ts) < N), array<T, N> >
// array_from_initializer_list(const T *const beg, const T *const end,
//                             const Ts &... xs) {
//   return array_from_initializer_list<T, N>(beg, end - 1,
//                                            beg < end ? *(end - 1) : T{},
//                                            xs...);
// }
// } // namespace
//
// template <typename T, size_t N>
// /*CCTK_ATTRIBUTE_ALWAYS_INLINE*/ constexpr array<T, N>
// array_from_initializer_list(initializer_list<T> l) {
//   return array_from_initializer_list<T, N>(l.begin(), l.end());
// }
template <typename T, size_t N>
/*CCTK_ATTRIBUTE_ALWAYS_INLINE*/ constexpr enable_if_t<(N == 3), array<T, N> >
array_from_initializer_list(initializer_list<T> l) {
  assert(l.size() >= N);
  const T *restrict const p = l.begin();
  return {p[0], p[1], p[2]};

Deletion in CarpetX/src/loop.hxx at line 89 [5.5481]
B:BD[4.651] → [4.651:666]
```
} // namespace
```

Replacement in CarpetX/src/loop.hxx at line 91 [5.5481]

B:BD[4.699] → [2.68:123]

/*CCTK_ATTRIBUTE_ALWAYS_INLINE*/ constexpr array<T, N>

[4.699]

[2.123]

/*CCTK_ATTRIBUTE_ALWAYS_INLINE*/ constexpr enable_if_t<(N == 6), array<T, N> >

Replacement in CarpetX/src/loop.hxx at line 93 [5.5481]

∅:D[2.176] → [4.774:838]

B:BD[4.774] → [4.774:838]

  return array_from_initializer_list<T, N>(l.begin(), l.end());

[2.176]

[4.838]

  assert(l.size() >= N);
  const T *restrict const p = l.begin();
  return {p[0], p[1], p[2], p[3], p[4], p[5]};

Insertion in CarpetX/src/loop.hxx at line 98 [5.5481]

[4.841]

[6.1]

static_assert(static_cast<const array<int, 3> &>(
                  array_from_initializer_list<int, 3>({0, 1, 2}))[0] == 0,
              "");
static_assert(static_cast<const array<int, 3> &>(
                  array_from_initializer_list<int, 3>({0, 1, 2}))[1] == 1,
              "");
static_assert(static_cast<const array<int, 3> &>(
                  array_from_initializer_list<int, 3>({0, 1, 2}))[2] == 2,
              "");

Replacement in CarpetX/src/loop.hxx at line 116 [5.5481]

B:BD[2.337] → [2.337:412]

∅:D[2.412] → [4.884:939]

B:BD[4.884] → [4.884:939]

  /*CCTK_ATTRIBUTE_ALWAYS_INLINE*/ constexpr vect(initializer_list<T> arr)
      : elts(array_from_initializer_list<T, D>(arr)) {

[2.337]

[4.939]

  /*CCTK_ATTRIBUTE_ALWAYS_INLINE*/ constexpr vect(initializer_list<T> lst)
      : elts(array_from_initializer_list<T, D>(lst)) {

Replacement in CarpetX/src/loop.hxx at line 119 [5.5481]
B:BD[4.957] → [4.957:986]
```
    assert(arr.size() == D);
```
[4.957]
[4.986]
```
    assert(lst.size() == D);
```
Insertion in CarpetX/src/loop.hxx at line 138 [5.5481]
[2.637]
[2.637]
```
#ifdef CCTK_DEBUG
    assert(d >= 0 && d < D);
#endif
```

Replacement in CarpetX/src/loop.hxx at line 143 [5.5481]

B:BD[2.661] → [2.661:737]

  /*CCTK_ATTRIBUTE_ALWAYS_INLINE*/ T &operator[](int d) { return elts[d]; }

[2.661]

[6.398]

  /*CCTK_ATTRIBUTE_ALWAYS_INLINE*/ constexpr T &operator[](int d) {
#ifdef CCTK_DEBUG
    assert(d >= 0 && d < D);
#endif
    return elts[d];
  }

Insertion in CarpetX/src/loop.hxx at line 374 [5.5481]

[7.3031]


namespace static_test {
constexpr vect<int, 3> vect1{0, 1, 2};
static_assert(vect1[0] == 0, "");
static_assert(vect1[1] == 1, "");
static_assert(vect1[2] == 2, "");
constexpr vect<vect<int, 3>, 3> vect2{
    {100, 101, 102},
    {110, 111, 112},
    {120, 121, 122},
};
static_assert(vect2[0][0] == 100, "");
static_assert(vect2[0][1] == 101, "");
static_assert(vect2[0][2] == 102, "");
static_assert(vect2[1][0] == 110, "");
static_assert(vect2[1][1] == 111, "");
static_assert(vect2[1][2] == 112, "");
static_assert(vect2[2][0] == 120, "");
static_assert(vect2[2][1] == 121, "");
static_assert(vect2[2][2] == 122, "");
} // namespace static_test

Replacement in CarpetX/src/loop.hxx at line 494 [5.5481]
B:BD[8.496] → [8.496:537]
```
      const vect<int, dim> I{{i, j, k}};
```
[8.496]
[8.537]
```
      const vect<int, dim> I{i, j, k};
```