NDArray.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <exception>
#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
 
namespace volcart
{
template <typename T>
class NDArray
{
public:
    using Container = std::vector<T>;
    using IndexType = typename Container::size_type;
    using Extent = std::vector<IndexType>;
    using Index = std::vector<IndexType>;
    using iterator = typename Container::iterator;
    using const_iterator = typename Container::const_iterator;
 
    explicit NDArray(std::size_t n) : dim_(n) {}
 
    explicit NDArray(std::size_t n, Extent e) : dim_(n), extents_(std::move(e))
    {
        if (extents_.size() != dim_) {
            throw std::invalid_argument("Extents of wrong dimension");
        }
 
        resize_container_();
    }
 
    template <typename... Es>
    explicit NDArray(std::size_t n, Es... extents)
        : dim_(n), extents_{static_cast<IndexType>(extents)...}
    {
        if (sizeof...(extents) != dim_) {
            throw std::invalid_argument("Extents of wrong dimension");
        }
        resize_container_();
    }
 
    template <typename InputIt>
    explicit NDArray(std::size_t n, Extent e, InputIt first, InputIt last)
        : dim_(n), extents_(std::move(e)), data_{first, last}
    {
        if (extents_.size() != dim_) {
            throw std::invalid_argument("Extents of wrong dimension");
        }
 
        auto size = std::accumulate(
            extents_.begin(), extents_.end(), IndexType(1),
            std::multiplies<IndexType>());
 
        if (size != data_.size()) {
            throw std::invalid_argument(
                "Array extent does not match size of input data");
        }
    }
    void setExtents(Extent e)
    {
        if (e.size() != dim_) {
            throw std::invalid_argument("Extents of wrong dimension");
        }
 
        extents_ = std::move(e);
        resize_container_();
    }
 
    template <typename... Es>
    void setExtents(Es... extents)
    {
        return setExtents({static_cast<IndexType>(extents)...});
    }
 
    auto dims() const -> std::size_t { return dim_; }
 
    auto extents() const -> Extent { return extents_; }
 
    auto size() const -> std::size_t { return data_.size(); }
    auto operator()(Index index) -> T&
    {
 
        if (index.size() != dim_) {
            throw std::invalid_argument("Index of wrong dimension");
        }
        return data_.at(index_to_data_index_(index));
    }
 
    auto operator()(Index index) const -> const T&
    {
        if (index.size() != dim_) {
            throw std::invalid_argument("Index of wrong dimension");
        }
        return data_.at(index_to_data_index_(index));
    }
 
    template <typename... Is>
    auto operator()(Is... indices) -> T&
    {
        return operator()(Index{static_cast<IndexType>(indices)...});
    }
 
    template <typename... Is>
    auto operator()(Is... indices) const -> const T&
    {
        return operator()(Index{static_cast<IndexType>(indices)...});
    }
 
    auto slice(IndexType index) -> NDArray
    {
        auto offset = std::accumulate(
            std::next(extents_.begin(), 1), extents_.end(), IndexType(1),
            std::multiplies<IndexType>());
 
        auto b = std::next(data_.begin(), index * offset);
        auto e = std::next(data_.begin(), (index + 1) * offset);
 
        Extent newExtent{std::next(extents_.begin(), 1), extents_.end()};
 
        return NDArray(dim_ - 1, newExtent, b, e);
    }
    auto as_vector() -> Container { return data_; }
 
    auto as_vector() const -> Container { return data_; }
 
    auto data() -> typename Container::value_type* { return data_.data(); }
 
    auto data() const -> typename Container::value_type*
    {
        return data_.data();
    }
 
    auto begin() -> iterator { return std::begin(data_); }
 
    auto begin() const -> const_iterator { return std::begin(data_); }
 
    auto end() -> iterator { return std::end(data_); }
 
    auto end() const -> const_iterator { return std::end(data_); }
 
    auto front() -> T& { return data_.front(); }
 
    auto front() const -> const T& { return data_.front(); }
 
    auto back() -> T& { return data_.back(); }
 
    auto back() const -> const T& { return data_.back(); }
    static void Flatten(NDArray& a, std::size_t dim)
    {
        if (dim == a.dim_) {
            return;
        } else if (dim > a.dim_) {
            throw std::invalid_argument("Dimension higher than that of array");
        }
 
        Extent newExtent;
 
        auto flattened = std::accumulate(
            a.extents_.begin(), std::next(a.extents_.begin(), a.dim_ - dim + 1),
            IndexType(1), std::multiplies<IndexType>());
        newExtent.push_back(flattened);
 
        newExtent.insert(
            newExtent.end(), std::next(a.extents_.begin(), a.dim_ - dim + 1),
            a.extents_.end());
 
        a.dim_ = dim;
        a.extents_ = newExtent;
    }
 
private:
    std::size_t dim_{1};
    Extent extents_;
    Container data_;
 
    void resize_container_()
    {
        auto size = std::accumulate(
            extents_.begin(), extents_.end(), IndexType(1),
            std::multiplies<IndexType>());
 
        if (size == 0) {
            throw std::range_error("Array extent is zero");
        }
 
        data_.resize(size);
    }
 
    inline auto index_to_data_index_(Index i) const -> IndexType
    {
        IndexType idx{0};
        for (std::size_t it = 0; it < extents_.size(); it++) {
            auto begin = std::next(extents_.begin(), it + 1);
            auto offset = std::accumulate(
                begin, extents_.end(), IndexType(1),
                std::multiplies<IndexType>());
            idx += i[it] * offset;
        }
 
        return idx;
    }
};
}  // namespace volcart