array.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2025                                                    *
 * Visual Computing Lab                                                      *
 * ISTI - Italian National Research Council                                  *
 *                                                                           *
 * All rights reserved.                                                      *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the Mozilla Public License Version 2.0 as published *
 * by the Mozilla Foundation; either version 2 of the License, or            *
 * (at your option) any later version.                                       *
 *                                                                           *
 * This program is distributed in the hope that it will be useful,           *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the              *
 * Mozilla Public License Version 2.0                                        *
 * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
 ****************************************************************************/
 
#ifndef VCL_SPACE_CORE_ARRAY_H
#define VCL_SPACE_CORE_ARRAY_H
 
#include <vclib/base.h>
 
#include <array>
#include <cassert>
#include <iomanip>
#include <utility>
#include <vector>
 
namespace vcl {
 
template<class T, uint N>
class Array
{
    static_assert(N > 0, "Array dimension must be > 0.");
    friend Array<T, N + 1>;
 
    std::array<std::size_t, N> mSizes;
    std::vector<T>             mVec;
 
public:
    using ValueType = std::vector<T>::value_type;
 
    using Scalar = ValueType;
 
    using ConstReference = std::vector<T>::const_reference;
 
    using Reference = std::vector<T>::reference;
 
    using ConstPointer = std::vector<T>::const_pointer;
 
    using Pointer = std::vector<T>::pointer;
 
    using Iterator = std::vector<T>::iterator;
 
    using ConstIterator = std::vector<T>::const_iterator;
 
    static constexpr uint DIM = N;
 
    Array() : mVec(0) { mSizes.fill(0); }
 
    template<typename... Sizes>
    Array(Sizes... s) requires (sizeof...(s) == N)
    {
        std::size_t args[N]   = {static_cast<std::size_t>(s)...};
        std::size_t totalSize = 1;
        for (uint i = 0; i < N; i++) {
            mSizes[i] = args[i];
            totalSize *= args[i];
        }
        mVec.resize(totalSize);
    }
 
    Array(NestedInitializerLists<T, N> values)
    {
        initializeNestedLists(values);
    }
 
    bool empty() const { return mVec.empty(); }
 
    std::size_t size(std::size_t dim) const
    {
        assert(dim < N);
        return mSizes[dim];
    }
 
    std::size_t rows() const requires (N == 2) { return mSizes[0]; }
 
    std::size_t cols() const requires (N == 2) { return mSizes[1]; }
 
    std::size_t sizeX() const requires (N >= 1) { return mSizes[0]; }
 
    std::size_t sizeY() const requires (N >= 2) { return mSizes[1]; }
 
    std::size_t sizeZ() const requires (N >= 3) { return mSizes[2]; }
 
    std::size_t sizeW() const requires (N >= 4) { return mSizes[3]; }
 
    template<typename... I>
    Reference operator()(I... indices) requires (sizeof...(indices) == N)
    {
        std::size_t args[N] = {static_cast<std::size_t>(indices)...};
        return mVec[getIndex(args)];
    }
 
    template<typename... I>
    ConstReference operator()(I... indices) const
        requires (sizeof...(indices) == N)
    {
        std::size_t args[N] = {static_cast<std::size_t>(indices)...};
        return mVec[getIndex(args)];
    }
 
    template<typename... I>
    Pointer data(I... indices) requires (sizeof...(indices) < N)
    {
        return const_cast<Pointer>(std::as_const(*this).data(indices...));
    }
 
    template<typename... I>
    ConstPointer data(I... indices) const requires (sizeof...(indices) < N)
    {
        constexpr std::size_t n = sizeof...(indices);
        if constexpr (n == 0) {
            return mVec.data();
        }
        else {
            std::size_t args[] = {static_cast<std::size_t>(indices)...};
            std::size_t ind    = args[0];
            assert(args[0] < mSizes[0]);
            uint i;
            for (i = 1; i < n; i++) {
                assert(args[i] < mSizes[i]);
                ind *= mSizes[i];
                ind += args[i];
            }
            for (; i < N; i++) {
                ind *= mSizes[i];
            }
            return &mVec[ind];
        }
    }
 
    std::vector<T> stdVector() & { return mVec; }
 
    std::vector<T>&& stdVector() && { return std::move(mVec); }
 
    const std::vector<T>& stdVector() const& { return mVec; }
 
    void fill(const T& t) { std::fill(mVec.begin(), mVec.end(), t); }
 
    template<Range Rng>
    void fill(Rng&& r)
    {
        uint i = 0;
        for (auto it = std::ranges::begin(r);
             it != std::ranges::end(r) && i < mVec.size();
             ++i, ++it) {
            mVec[i] = *it;
        }
    }
 
    template<typename... Sizes>
    void resize(Sizes... s) requires (sizeof...(s) == N)
    {
        std::size_t args[N]   = {static_cast<std::size_t>(s)...};
        std::size_t totalSize = 1;
        for (uint i = 0; i < N; i++) {
            mSizes[i] = args[i];
            totalSize *= args[i];
        }
        mVec.resize(totalSize);
    }
 
    template<typename... Sizes>
    void conservativeResize(Sizes... s) requires (sizeof...(s) == N)
    {
        std::size_t newSizes[N]  = {static_cast<std::size_t>(s)...};
        std::size_t newTotalSize = 1;
        for (uint i = 0; i < N; i++)
            newTotalSize *= newSizes[i];
        std::vector<T> newVector(newTotalSize);
 
        for (std::size_t i = 0; i < mVec.size(); i++) {
            std::array<std::size_t, N> indices    = reverseIndex(i);
            bool                       outOfBound = false;
            for (std::size_t j = 0; j < N; j++)
                if (indices[j] >= newSizes[j] || indices[j] >= mSizes[j])
                    outOfBound = true;
            if (!outOfBound) {
                newVector[getIndex(indices.data(), newSizes)] = mVec[i];
            }
        }
 
        for (uint i = 0; i < mSizes.size(); i++) {
            mSizes[i] = newSizes[i];
        }
 
        mVec = std::move(newVector);
    }
 
    void clear()
    {
        mVec.clear();
        for (uint i = 0; i < N; i++)
            mSizes[i] = 0;
    }
 
    Array<T, N - 1> subArray(uint r) const requires (N > 1)
    {
        assert(r < mSizes[0]);
        Array<T, N - 1> sub;
        size_t          size = 1;
        for (uint i = 0; i < mSizes.size() - 1; i++) {
            sub.mSizes[i] = mSizes[i + 1];
            size *= sub.mSizes[i];
        }
        sub.mVec = std::vector<T>(
            mVec.begin() + r * size, mVec.begin() + (r + 1) * size);
        return sub;
    }
 
    void serialize(std::ostream& os) const
    {
        vcl::serialize(os, mSizes);
        vcl::serialize(os, mVec);
    }
 
    void deserialize(std::istream& is)
    {
        vcl::deserialize(is, mSizes);
        vcl::deserialize(is, mVec);
    }
 
    Iterator begin() { return mVec.begin(); }
 
    Iterator end() { return mVec.end(); }
 
    ConstIterator begin() const { return mVec.begin(); }
 
    ConstIterator end() const { return mVec.end(); }
 
    template<typename S>
    friend std::ostream& operator<<(std::ostream& out, const Array<S, 2>& a);
 
private:
    std::size_t getIndex(const std::size_t indices[]) const
    {
        std::size_t ind = indices[0];
        assert(indices[0] < mSizes[0]);
        for (uint i = 1; i < N; i++) {
            assert(indices[i] < mSizes[i]);
            ind *= mSizes[i];
            ind += indices[i];
        }
        return ind;
    }
 
    std::array<std::size_t, N> reverseIndex(uint index)
    {
        std::array<std::size_t, N> indices;
        for (long int i = N - 1; i >= 0; i--) {
            indices[i] = index % mSizes[i];
            index /= mSizes[i];
        }
        return indices;
    }
 
    static std::size_t getIndex(
        const std::size_t indices[],
        const std::size_t sizes[])
    {
        std::size_t ind = indices[0];
        assert(indices[0] < sizes[0]);
        for (uint i = 1; i < N; i++) {
            assert(indices[i] < sizes[i]);
            ind *= sizes[i];
            ind += indices[i];
        }
        return ind;
    }
 
    void initializeNestedLists(NestedInitializerLists<T, N> values)
    {
        std::list<std::size_t> szs =
            NestedInitializerListsProcessor<T, N>::maxDimensionsLevels(values);
 
        uint   i         = 0;
        size_t totalSize = 1;
        for (std::size_t s : szs) {
            totalSize *= s;
            mSizes[i++] = s;
        }
        mVec.resize(totalSize);
 
        typename std::vector<T>::iterator iterator = mVec.begin();
        NestedInitializerListsProcessor<T, N>::processElements(
            values,
            [&iterator](T value) {
                *(iterator++) = value;
            },
            szs);
    }
};
 
template<typename Scalar>
std::ostream& operator<<(std::ostream& out, const Array<Scalar, 2>& a)
{
    for (uint i = 0; i < a.sizeX(); i++) {
        for (uint j = 0; j < a.sizeY(); j++) {
            out << std::setw(4) << a(i, j) << " ";
        }
        out << std::endl;
    }
    return out;
}
 
/* Specialization Aliases */
 
template<typename Scalar>
using Array2 = Array<Scalar, 2>;
 
template<typename Scalar>
using Array3 = Array<Scalar, 3>;
 
template<typename Scalar>
using Array4 = Array<Scalar, 4>;
 
/* Concepts */
 
template<typename T>
concept ArrayConcept = std::derived_from< // same type or derived type
    std::remove_cvref_t<T>,
    Array<typename RemoveRef<T>::ValueType, RemoveRef<T>::DIM>>;
 
template<typename T>
concept Array2Concept = ArrayConcept<T> && RemoveRef<T>::DIM == 2;
 
template<typename T>
concept Array3Concept = ArrayConcept<T> && RemoveRef<T>::DIM == 3;
 
template<typename T>
concept Array4Concept = ArrayConcept<T> && RemoveRef<T>::DIM == 4;
 
} // namespace vcl
 
#endif // VCL_SPACE_CORE_ARRAY_H