strided_layout_constexpr.h

Go to the documentation of this file.

#pragma once
 
#include "config.h"
#include "containers/array.h"
#include "helper_traits.h"
 
template <bool Enabled, my_size_t... Vals>
struct PermValidation
{
    static constexpr bool unique = true;
    static constexpr my_size_t max_val = 0;
    static constexpr my_size_t min_val = 0;
};
 
template <my_size_t... Vals>
struct PermValidation<true, Vals...>
{
    static constexpr bool unique = all_unique<Vals...>();
    static constexpr my_size_t max_val = max_value<Vals...>();
    static constexpr my_size_t min_val = min_value<Vals...>();
};
 
template <typename PadPolicy, my_size_t... Perm>
struct StridedLayoutConstExpr
{
    static constexpr my_size_t NumDims = PadPolicy::NumDims;
    static constexpr my_size_t LogicalSize = PadPolicy::LogicalSize;
    static constexpr my_size_t PhysicalSize = PadPolicy::PhysicalSize;
    static constexpr bool IsPermProvided = sizeof...(Perm) > 0;
 
    using PadPolicyType = PadPolicy;
 
private:
    using PermCheck = PermValidation<IsPermProvided, Perm...>;
 
    static_assert(!IsPermProvided || sizeof...(Perm) == NumDims,
                  "Permutation must match number of dimensions");
 
    static_assert(!IsPermProvided || PermCheck::unique,
                  "Permutations must be unique");
 
    static_assert(!IsPermProvided || PermCheck::max_val < NumDims,
                  "Max value of permutation pack must be less than number of dimensions");
 
    static_assert(!IsPermProvided || PermCheck::min_val == 0,
                  "Min value of permutation pack is not equal to 0");
 
    static constexpr Array<my_size_t, NumDims> computePermArray() noexcept
    {
        if constexpr (IsPermProvided)
        {
            return Array<my_size_t, NumDims>{Perm...};
        }
        else
        {
            Array<my_size_t, NumDims> result{};
            for (my_size_t i = 0; i < NumDims; ++i)
            {
                result[i] = i;
            }
            return result;
        }
    }
 
    static constexpr Array<my_size_t, NumDims> PermArray = computePermArray();
 
    static constexpr Array<my_size_t, NumDims> computeInversePermArray() noexcept
    {
        Array<my_size_t, NumDims> result{};
        for (my_size_t i = 0; i < NumDims; ++i)
        {
            result[PermArray[i]] = i;
        }
        return result;
    }
 
    static constexpr Array<my_size_t, NumDims> InversePermArray = computeInversePermArray();
 
    static constexpr Array<my_size_t, NumDims> computeLogicalDims() noexcept
    {
        Array<my_size_t, NumDims> result{};
        for (my_size_t i = 0; i < NumDims; ++i)
        {
            result[i] = PadPolicy::LogicalDims[PermArray[i]];
        }
        return result;
    }
 
    static constexpr Array<my_size_t, NumDims> LogicalDims = computeLogicalDims();
 
    static constexpr Array<my_size_t, NumDims> computeBaseStrides() noexcept
    {
        Array<my_size_t, NumDims> result{};
        result[NumDims - 1] = 1;
        for (my_size_t i = NumDims - 1; i > 0; --i)
        {
            result[i - 1] = result[i] * PadPolicy::PhysicalDims[i];
        }
        return result;
    }
 
    static constexpr Array<my_size_t, NumDims> BaseStrides = computeBaseStrides();
 
    static constexpr Array<my_size_t, NumDims> computeStrides() noexcept
    {
        // Permute the BaseStrides
        Array<my_size_t, NumDims> result{};
        for (my_size_t i = 0; i < NumDims; ++i)
        {
            result[i] = BaseStrides[PermArray[i]];
        }
        return result;
    }
 
    static constexpr Array<my_size_t, NumDims> Strides = computeStrides();
 
    static constexpr Array<my_size_t, NumDims> computeLogicalStrides() noexcept
    {
        Array<my_size_t, NumDims> result{};
        result[NumDims - 1] = 1;
        for (my_size_t i = NumDims - 1; i > 0; --i)
        {
            result[i - 1] = result[i] * LogicalDims[i];
        }
        return result;
    }
 
    static constexpr Array<my_size_t, NumDims> LogicalStrides = computeLogicalStrides();
 
public:
    FORCE_INLINE static constexpr my_size_t num_dims() noexcept { return NumDims; }
 
    FORCE_INLINE static constexpr my_size_t perm_array(my_size_t i) TESSERACT_CONDITIONAL_NOEXCEPT
    {
        return PermArray.at(i);
    }
 
    FORCE_INLINE static constexpr my_size_t inverse_perm_array(my_size_t i) TESSERACT_CONDITIONAL_NOEXCEPT
    {
        return InversePermArray.at(i);
    }
 
    FORCE_INLINE static constexpr my_size_t logical_dim(my_size_t i) TESSERACT_CONDITIONAL_NOEXCEPT
    {
        return LogicalDims.at(i);
    }
 
    FORCE_INLINE static constexpr my_size_t base_stride(my_size_t i) TESSERACT_CONDITIONAL_NOEXCEPT
    {
        return BaseStrides.at(i);
    }
 
    FORCE_INLINE static constexpr my_size_t stride(my_size_t i) TESSERACT_CONDITIONAL_NOEXCEPT
    {
        return Strides.at(i);
    }
 
    FORCE_INLINE static constexpr my_size_t logical_stride(my_size_t i) TESSERACT_CONDITIONAL_NOEXCEPT
    {
        return LogicalStrides.at(i);
    }
 
    // ========================================================================
    // INDEX CONVERSION
    // ========================================================================
 
    FORCE_INLINE static constexpr my_size_t logical_flat_to_physical_flat(my_size_t logical_flat) TESSERACT_CONDITIONAL_NOEXCEPT
    {
        if (logical_flat >= LogicalSize)
        {
            MyErrorHandler::error("logical_flat_to_physical_flat: logical_flat index out of bounds");
        }
        my_size_t offset = 0;
        for (my_size_t i = 0; i < NumDims; ++i)
        {
            const my_size_t s = LogicalStrides[i];
            const my_size_t idx = logical_flat / s;
            logical_flat -= idx * s;
            offset += idx * Strides[i];
        }
        return offset;
    }
 
    FORCE_INLINE static constexpr bool is_logical_index_in_bounds(const my_size_t (&indices)[NumDims]) noexcept
    {
        for (my_size_t i = 0; i < NumDims; ++i)
        {
            if (indices[i] >= LogicalDims[i])
                return false;
        }
        return true;
    }
 
    FORCE_INLINE static constexpr my_size_t logical_coords_to_physical_flat(const my_size_t (&indices)[NumDims]) TESSERACT_CONDITIONAL_NOEXCEPT
    {
        if (!is_logical_index_in_bounds(indices))
        {
            MyErrorHandler::error("logical_coords_to_physical_flat: index out of bounds for logical dimension");
        }
 
        my_size_t flat = 0;
        for (my_size_t i = 0; i < NumDims; ++i)
        {
            flat += indices[i] * Strides[i];
        }
        return flat;
    }
 
    template <typename... Indices>
    FORCE_INLINE static constexpr my_size_t logical_coords_to_physical_flat(Indices... indices) TESSERACT_CONDITIONAL_NOEXCEPT
    {
        static_assert(sizeof...(Indices) == NumDims, "Wrong number of indices");
        my_size_t idx_arr[] = {static_cast<my_size_t>(indices)...};
        return logical_coords_to_physical_flat(idx_arr);
    }
 
    FORCE_INLINE static constexpr void logical_flat_to_logical_coords(my_size_t logical_flat, my_size_t (&indices)[NumDims]) TESSERACT_CONDITIONAL_NOEXCEPT
    {
        // check logical_flat is in range
        if (logical_flat >= LogicalSize)
        {
            MyErrorHandler::error("logical_flat_to_logical_coords: logical_flat index out of bounds");
        }
        for (my_size_t i = 0; i < NumDims; ++i)
        {
            const my_size_t s = LogicalStrides[i];
            const my_size_t idx = logical_flat / s;
            indices[i] = idx;
            logical_flat -= idx * s;
        }
    }
 
    FORCE_INLINE static constexpr void physical_flat_to_physical_coords(my_size_t physical_flat, my_size_t (&indices)[NumDims]) TESSERACT_CONDITIONAL_NOEXCEPT
    {
        // check physical_flat is in range
        if (physical_flat >= PhysicalSize)
        {
            MyErrorHandler::error("physical_flat_to_physical_coords: physical_flat index out of bounds");
        }
 
        for (my_size_t i = 0; i < NumDims; ++i)
        {
            const my_size_t s = BaseStrides[i];
            const my_size_t idx = physical_flat / s;
            indices[i] = idx;
            physical_flat -= idx * s;
        }
    }
 
    // ========================================================================
    // REVERSE CONVERSION
    // ========================================================================
 
    FORCE_INLINE static constexpr void physical_flat_to_logical_coords(my_size_t physical_flat, my_size_t (&indices)[NumDims]) TESSERACT_CONDITIONAL_NOEXCEPT
    {
        if (physical_flat >= PhysicalSize)
        {
            MyErrorHandler::error("physical_flat_to_logical_coords: physical_flat index out of bounds");
        }
        // Step 1: Decompose into physical (unpermuted) coords
        my_size_t physical_coords[NumDims];
        for (my_size_t i = 0; i < NumDims; ++i)
        {
            const my_size_t s = BaseStrides[i];
            const my_size_t idx = physical_flat / s;
            physical_coords[i] = idx;
            physical_flat -= idx * s;
        }
 
        // Step 2: Apply forward permutation
        // logical[i] = physical[PermArray[i]]
        for (my_size_t i = 0; i < NumDims; ++i)
        {
            indices[i] = physical_coords[PermArray[i]];
        }
    }
};