Class array

src/targets/gpu/kernels/include/migraphx/kernels/array.hpp:123–316

template <class T, index_int N>
struct array
{
    using value_type = T;
    T d[N]           = {{}};

    constexpr array() = default;

    template <class... Ts,
              MIGRAPHX_REQUIRES(sizeof...(Ts) == N and (is_convertible<Ts, T>{} and ...))>
    constexpr array(Ts... xs) : d{static_cast<value_type>(xs)...}
    {
    }

    template <class U, MIGRAPHX_REQUIRES(is_convertible<U, T>{} and (N > 1))>
    constexpr explicit array(U x)
    {
        fill(this->begin(), this->end(), x);
    }

    constexpr T& operator[](index_int i)
    {
        MIGRAPHX_ASSERT(i < N);
        return d[i];
    }
    constexpr const T& operator[](index_int i) const
    {
        MIGRAPHX_ASSERT(i < N);
        return d[i];
    }

    constexpr T& front() { return d[0]; }
    constexpr const T& front() const { return d[0]; }

    constexpr T& back() { return d[N - 1]; }
    constexpr const T& back() const { return d[N - 1]; }

    constexpr T* data() { return d; }
    constexpr const T* data() const { return d; }

    constexpr index_constant<N> size() const { return {}; }
    constexpr auto empty() const { return size() == _c<0>; }

    constexpr T* begin() { return d; }
    constexpr const T* begin() const { return d; }

    constexpr T* end() { return d + size(); }
    constexpr const T* end() const { return d + size(); }

    constexpr T dot(const array& x) const
    {
        auto r = x * (*this);
        return r.reduce([](auto a, auto b) { return a + b; }, 0);
    }

    constexpr T product() const
    {
        return reduce([](auto x, auto y) { return x * y; }, 1);
    }