test/helloworld/at.test.cpp

#define PROBLEM "http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ITP1_1_A"
#include <cassert>
#include <iostream>

#include "../../Util/at.hpp"

void at_test_dim1_a() {
    using arumakan::at;
    constexpr int W = 5;
    int a[W];

    for (int i = 0; i < W; ++i) {
        at(a, i) = i;
        assert(&at(a, i) == &a[i]);
        assert(a[i] == i);
    }

    std::clog << __func__ << " : OK" << std::endl;
}

void at_test_dim1_b() {
    using arumakan::at;
    constexpr int W = 5;
    int a[W];
    using P1 = std::array<int, 1>;
    using P2 = std::tuple<int>;

    for (int i = 0; i < W; ++i) {
        at(a, P1{i}) = i;
        assert(a[i] == i);
        assert(&at(a, P1{i}) == &a[i]);
        assert(&at(a, P2{i}) == &a[i]);
    }

    std::clog << __func__ << " : OK" << std::endl;
}

void at_test_dim2() {
    using arumakan::at;
    constexpr int H = 3;
    constexpr int W = 4;
    int a[H][W];
    using P1 = std::array<int, 2>;
    using P2 = std::pair<int, int>;
    using P3 = std::tuple<int, int>;

    for (int i = 0; i < H; ++i) {
        for (int j = 0; j < W; ++j) {
            at(a, P1{i, j}) = i * W + j;
            assert(a[i][j] == i * W + j);
            assert(&at(a, P1{i, j}) == &a[i][j]);
            assert(&at(a, P2{i, j}) == &a[i][j]);
            assert(&at(a, P3{i, j}) == &a[i][j]);
        }
    }

    std::clog << __func__ << " : OK" << std::endl;
}

void at_test_dim3() {
    using arumakan::at;
    constexpr int D = 3;
    constexpr int H = 3;
    constexpr int W = 4;
    int a[D][H][W];
    using P1 = std::array<int, 3>;
    using P2 = std::tuple<int, int, int>;

    for (int z = 0; z < D; ++z) {
        for (int y = 0; y < H; ++y) {
            for (int x = 0; x < W; ++x) {
                at(a, P1{z, y, x}) = (z * H * W) + (y * H) + (x);
                assert(a[z][y][x] == (z * H * W) + (y * H) + (x));
                assert(&at(a, P1{z, y, x}) == &a[z][y][x]);
                assert(&at(a, P2{z, y, x}) == &a[z][y][x]);
            }
        }
    }

    std::clog << __func__ << " : OK" << std::endl;
}

int main() {
    std::cout << "Hello World" << std::endl;

    at_test_dim1_a();
    at_test_dim1_b();
    at_test_dim2();
    at_test_dim3();

    return 0;
}

#line 1 "test/helloworld/at.test.cpp"
#define PROBLEM "http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ITP1_1_A"
#include <cassert>
#include <iostream>

#line 2 "Util/at.hpp"
#include <tuple>
#include <functional>
#include <type_traits>

/**
 * @brief at() ()
 */
namespace arumakan {

//! at(a, i) returns a[i]
template <class Array, class Integer, std::enable_if_t<std::is_integral<Integer>::value, std::nullptr_t> = nullptr>
inline auto at(Array&& a, Integer i) -> decltype(a[0])& {
    return a[i];
}

//! at(a, Tuple{i}) returns a[i]
template <class Array, class Tuple, std::enable_if_t<std::tuple_size<Tuple>::value == 1, std::nullptr_t> = nullptr>
inline auto at(Array&& a, Tuple index) -> decltype(a[0])& {
    return a[std::get<0>(index)];
}

//! at(mat, Tuple{y, x}) returns mat[y][x]
template <class Matrix, class Tuple, std::enable_if_t<std::tuple_size<Tuple>::value == 2, std::nullptr_t> = nullptr>
inline auto at(Matrix&& mat, Tuple index) -> decltype(mat[0][0])& {
    return mat[std::get<0>(index)][std::get<1>(index)];
}

//! at(cube, Tuple{z, y, x}) returns cube[z][y][x]
template <class Cube, class Tuple, std::enable_if_t<std::tuple_size<Tuple>::value == 3, std::nullptr_t> = nullptr>
inline auto at(Cube&& cube, Tuple index) -> decltype(cube[0][0][0])& {
    return cube[std::get<0>(index)][std::get<1>(index)][std::get<2>(index)];
}

}  // namespace arumakan
#line 6 "test/helloworld/at.test.cpp"

void at_test_dim1_a() {
    using arumakan::at;
    constexpr int W = 5;
    int a[W];

    for (int i = 0; i < W; ++i) {
        at(a, i) = i;
        assert(&at(a, i) == &a[i]);
        assert(a[i] == i);
    }

    std::clog << __func__ << " : OK" << std::endl;
}

void at_test_dim1_b() {
    using arumakan::at;
    constexpr int W = 5;
    int a[W];
    using P1 = std::array<int, 1>;
    using P2 = std::tuple<int>;

    for (int i = 0; i < W; ++i) {
        at(a, P1{i}) = i;
        assert(a[i] == i);
        assert(&at(a, P1{i}) == &a[i]);
        assert(&at(a, P2{i}) == &a[i]);
    }

    std::clog << __func__ << " : OK" << std::endl;
}

void at_test_dim2() {
    using arumakan::at;
    constexpr int H = 3;
    constexpr int W = 4;
    int a[H][W];
    using P1 = std::array<int, 2>;
    using P2 = std::pair<int, int>;
    using P3 = std::tuple<int, int>;

    for (int i = 0; i < H; ++i) {
        for (int j = 0; j < W; ++j) {
            at(a, P1{i, j}) = i * W + j;
            assert(a[i][j] == i * W + j);
            assert(&at(a, P1{i, j}) == &a[i][j]);
            assert(&at(a, P2{i, j}) == &a[i][j]);
            assert(&at(a, P3{i, j}) == &a[i][j]);
        }
    }

    std::clog << __func__ << " : OK" << std::endl;
}

void at_test_dim3() {
    using arumakan::at;
    constexpr int D = 3;
    constexpr int H = 3;
    constexpr int W = 4;
    int a[D][H][W];
    using P1 = std::array<int, 3>;
    using P2 = std::tuple<int, int, int>;

    for (int z = 0; z < D; ++z) {
        for (int y = 0; y < H; ++y) {
            for (int x = 0; x < W; ++x) {
                at(a, P1{z, y, x}) = (z * H * W) + (y * H) + (x);
                assert(a[z][y][x] == (z * H * W) + (y * H) + (x));
                assert(&at(a, P1{z, y, x}) == &a[z][y][x]);
                assert(&at(a, P2{z, y, x}) == &a[z][y][x]);
            }
        }
    }

    std::clog << __func__ << " : OK" << std::endl;
}

int main() {
    std::cout << "Hello World" << std::endl;

    at_test_dim1_a();
    at_test_dim1_b();
    at_test_dim2();
    at_test_dim3();

    return 0;
}