Subspace.h

Go to the documentation of this file.

#pragma once

 
#include <array>
#include <cstddef>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include <EmrysFilter/Core/Macros.h>
#include <EmrysFilter/Spaces/Composite.h>
#include <EmrysFilter/Spaces/Space.h>
#include <EmrysFilter/Spaces/TagPath.h>
 
namespace Emrys
{
 
namespace internal
{

template <typename P>
struct PathTagOf
{
    using type = P;
};

template <typename... Tags>
struct PathTagOf<TagPath<Tags...>>
{
    using type = std::tuple_element_t<sizeof...(Tags) - 1, std::tuple<Tags...>>;
};

template <typename P>
using PathTag = typename PathTagOf<P>::type;

template <typename P>
inline constexpr bool RunsThroughRepeated = false;
template <typename... Tags>
inline constexpr bool RunsThroughRepeated<TagPath<Tags...>> = [] {
    constexpr bool repeated[] = {IsRepeated<Tags>...};
    for (std::size_t i = 0; i + 1 < sizeof...(Tags); ++i)
    {
        if (repeated[i])
        {
            return true;
        }
    }
    return false;
}();


template <typename P, typename Space>
[[nodiscard]] PathTag<P> const &
pathBlock(Space const & space)
{
    return withPathTags<P>([&]<typename... Tags>() -> PathTag<P> const & {
        auto const * block = locatePath<Tags...>(space).second;
        return *block;
    });
}

template <typename Tag, typename Space>
[[nodiscard]] Tag const &
findTag(Space const & space)
{
    Tag const * block = locate<Tag>(space).second;
    return *block;
}

template <typename Space, typename Tag, typename... Rest>
[[nodiscard]] auto
subspace(Space const & space)
{
    Tag const & tag = findTag<Tag>(space);
    if constexpr (sizeof...(Rest) == 0)
    {
        return tag;
    }
    else if constexpr (IsRepeated<Tag>)
    {
        auto inner = subspace<RepeatedBlock<Tag>, Rest...>(tag.block());
        return Repeated<decltype(inner), Tag::MaxCount>{std::move(inner), tag.count()};
    }
    else
    {
        return subspace<Tag, Rest...>(tag);
    }
}

template <typename Space, typename... Path>
using SubspaceType = decltype(subspace<Space, Path...>(std::declval<Space const &>()));

template <typename RepeatedTag, typename... Inner, typename Space>
[[nodiscard]] auto
elementSubspace(Space const & space)
{
    static_assert(IsRepeated<RepeatedTag>, "this takes a repeated block");
    auto const & block = findTag<RepeatedTag>(space).block();
    if constexpr (sizeof...(Inner) == 0)
    {
        return block;
    }
    else
    {
        return subspace<RepeatedBlock<RepeatedTag>, Inner...>(block);
    }
}

template <typename... Blocks>
[[nodiscard]] auto
joinBlocks(std::tuple<Blocks...> blocks)
{
    if constexpr (sizeof...(Blocks) == 0)
    {
        return Linear<0>{};
    }
    else if constexpr (sizeof...(Blocks) == 1)
    {
        return std::get<0>(std::move(blocks));
    }
    else
    {
        return std::apply(
            [](Blocks &... b) {
                return Composite<Blocks...>{std::move(b)...};
            },
            blocks
        );
    }
}
 
template <typename Tag, typename... Rest, typename Space>
[[nodiscard]] auto
blocksWithout(Space const & space);  // defined below; blockWithout() recurses into it

template <typename Tag, typename... Rest, typename Block>
[[nodiscard]] auto
blockWithout(Block const & block)
{
    if constexpr (countTag<Tag, Block>() > 0)
    {
        return blocksWithout<Tag, Rest...>(block);
    }
    else
    {
        return std::tuple<Block>{block};
    }
}

template <typename Tag, typename... Rest, typename Space>
[[nodiscard]] auto
blocksWithout(Space const & space)
{
    if constexpr (std::is_same_v<Tag, Space>)
    {
        if constexpr (sizeof...(Rest) == 0)
        {
            return std::tuple<>{};
        }
        else if constexpr (IsRepeated<Tag>)
        {
            auto rest = blocksWithout<Rest...>(space.block());
            if constexpr (std::tuple_size_v<decltype(rest)> == 0)
            {
                return std::tuple<>{};
            }
            else
            {
                auto block = joinBlocks(std::move(rest));
                return std::tuple<Repeated<decltype(block), Tag::MaxCount>>{
                    Repeated<decltype(block), Tag::MaxCount>{std::move(block), space.count()}
                };
            }
        }
        else
        {
            return blocksWithout<Rest...>(space);
        }
    }
    else
    {
        static_assert(
            !IsUntagged<Tag>,
            "a path names blocks by tag; derive one, such as struct Heading : RadiansPi<> {}"
        );
        static_assert(IsComposite<Space>, "the space does not contain this tag");
        return [&]<std::size_t... I>(std::index_sequence<I...>) {
            return std::tuple_cat(blockWithout<Tag, Rest...>(space.template block<I>())...);
        }(std::make_index_sequence<std::tuple_size_v<CompositeBlocks<Space>>>{});
    }
}

template <typename... Given, typename Space>
[[nodiscard]] auto
complementSubspace(Space const & space)
{
    return joinBlocks(blocksWithout<Given...>(space));
}

template <typename P, typename Space>
[[nodiscard]] auto
pathSubspace(Space const & space)
{
    return withPathTags<P>([&]<typename... Tags>() {
        return subspace<Space, Tags...>(space);
    });
}

template <typename Space, typename P>
using PathSubspaceType = decltype(pathSubspace<P>(std::declval<Space const &>()));

template <typename P, typename Space>
[[nodiscard]] auto
pathElementSubspace(Space const & space)
{
    return withPathTags<P>([&]<typename... Tags>() {
        return elementSubspace<Tags...>(space);
    });
}

template <typename P, typename Space>
[[nodiscard]] auto
pathComplement(Space const & space)
{
    return withPathTags<P>([&]<typename... Tags>() {
        return complementSubspace<Tags...>(space);
    });
}

template <typename Block>
concept IsElementwise = IsRepeated<Block> || (IsUniformLeaf<Block> && Block::ValueDimensionStep != 0);

template <IsElementwise Block>
[[nodiscard]] Eigen::Index
elementCount(Block const & block)
{
    if constexpr (IsRepeated<Block>)
    {
        return block.count();
    }
    else
    {
        return block.valueDimension();
    }
}

template <IsElementwise Block>
void
setElementCount(Block & block, Eigen::Index count)
{
    if constexpr (IsRepeated<Block>)
    {
        block.setCount(count);
    }
    else
    {
        block.resize(count);
    }
}

struct ElementRows
{
    Eigen::Index start;            
    Eigen::Index count;            
    Eigen::Index differenceStart;  
    Eigen::Index differenceCount;  
};

template <typename Path, typename Space>
[[nodiscard]] auto
locateElementwise(Space & space)
{
    auto [offset, block] = withPathTags<Path>([&]<typename... Tags>() {
        return locatePathIn<false, Tags...>(space);
    });
    Eigen::Index const differenceOffset = withPathTags<Path>([&]<typename... Tags>() {
        return locatePathIn<true, Tags...>(space).first;
    });
    using Block = std::remove_pointer_t<decltype(block)>;
    static_assert(
        IsElementwise<Block>,
        "insert() and erase() take a Repeated block or a resizable Linear or Periodic block"
    );
    return std::tuple{offset, differenceOffset, block};
}

template <typename Path, typename Space>
[[nodiscard]] ElementRows
growBlock(Space & space, Eigen::Index element, Eigen::Index rows)
{
    auto [offset, differenceOffset, block] = locateElementwise<Path>(space);
    using Block = std::remove_pointer_t<decltype(block)>;
    constexpr Eigen::Index elementSize = Block::ValueDimensionStep;
    constexpr Eigen::Index differenceElementSize = SizedAs<true, Block>::ValueDimensionStep;
    Eigen::Index const count = elementCount(*block);
    EMRYS_FILTER_ASSERT(element >= 0 && element <= count && "insertion point out of range");
    EMRYS_FILTER_ASSERT(rows % elementSize == 0 && "insert whole elements");
    setElementCount(*block, count + rows / elementSize);
    return {
        offset + element * elementSize,
        rows,
        differenceOffset + element * differenceElementSize,
        rows / elementSize * differenceElementSize
    };
}

template <typename Path, typename Space>
[[nodiscard]] ElementRows
shrinkBlock(Space & space, Eigen::Index element, Eigen::Index elements)
{
    auto [offset, differenceOffset, block] = locateElementwise<Path>(space);
    using Block = std::remove_pointer_t<decltype(block)>;
    constexpr Eigen::Index elementSize = Block::ValueDimensionStep;
    constexpr Eigen::Index differenceElementSize = SizedAs<true, Block>::ValueDimensionStep;
    Eigen::Index const count = elementCount(*block);
    EMRYS_FILTER_ASSERT(element >= 0 && elements >= 0 && element + elements <= count && "erased elements out of range");
    setElementCount(*block, count - elements);
    return {
        offset + element * elementSize,
        elements * elementSize,
        differenceOffset + element * differenceElementSize,
        elements * differenceElementSize
    };
}

template <typename Indices>
[[nodiscard]] auto
asIndexSet(Indices const & indices)
{
    if constexpr (std::is_integral_v<Indices>)
    {
        return std::array<Eigen::Index, 1>{indices};
    }
    else
    {
        return indices;
    }
}
 
}  // namespace internal
 
}  // namespace Emrys