SwitchingModel.h

Go to the documentation of this file.

#pragma once

 
#include <algorithm>
#include <array>
#include <cstddef>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include <EmrysFilter/Core/Macros.h>
#include <EmrysFilter/Core/Math.h>
#include <EmrysFilter/Distributions/Categorical.h>
#include <EmrysFilter/Models/MeasurementModel.h>
#include <EmrysFilter/Models/ProcessModel.h>
#include <EmrysFilter/Spaces/Discrete.h>
#include <EmrysFilter/Spaces/Space.h>
#include <EmrysFilter/Spaces/Subspace.h>
 
namespace Emrys
{

template <typename Model_, typename Method_>
class ModelWithMethod
{
    static_assert(
        !isFixedStep<Model_> && !isUnboundStep<Model_>,
        "a fixed-step model carries its own method; give the method to fixedStep() in place of withMethod()"
    );
    static_assert(internal::checkPredictionMethod<Method_>());
 
public:
 
    using ModelType = Model_;    
    using MethodType = Method_;  

    ModelWithMethod(Model_ model, Method_ method)
        : m_model{std::move(model)}
        , m_method{std::move(method)}
    {}

    [[nodiscard]] Model_ const &
    model() const
    {
        return m_model;
    }

    [[nodiscard]] Model_ &
    model()
    {
        return m_model;
    }

    [[nodiscard]] Method_ const &
    method() const
    {
        return m_method;
    }
 
private:
 
    Model_ m_model;                                   
    EMRYS_FILTER_NO_UNIQUE_ADDRESS Method_ m_method;  
};
 
namespace internal
{

template <typename Model>
inline constexpr bool isModelWithMethod = false;

template <typename Model_, typename Method_>
inline constexpr bool isModelWithMethod<ModelWithMethod<Model_, Method_>> = true;


template <typename Model>
struct ModeModelOf
{
    using type = Model;  
};

template <typename Model_, typename Method_>
struct ModeModelOf<ModelWithMethod<Model_, Method_>>
{
    using type = Model_;  
};

template <typename Model>
using ModeModel = typename ModeModelOf<Model>::type;

template <typename Entry>
[[nodiscard]] auto &
modeModel(Entry & entry)
{
    if constexpr (isModelWithMethod<std::remove_const_t<Entry>>)
    {
        return entry.model();
    }
    else
    {
        return entry;
    }
}

template <typename Entry, typename Fallback>
[[nodiscard]] auto const &
modeMethod(Entry const & entry, Fallback const & fallback)
{
    if constexpr (isModelWithMethod<Entry> || isFixedStep<Entry>)
    {
        return entry.method();
    }
    else
    {
        return fallback;
    }
}
 
}  // namespace internal

template <typename Model, TransformMethod Method>
[[nodiscard]] ModelWithMethod<Model, Method>
withMethod(Model model, Method method)
{
    return {std::move(model), std::move(method)};
}

template <DiscreteSpace ModeSpace_, RealScalar Scalar_, typename Path_, typename... Models>
class SwitchingModel
{
    static_assert(sizeof...(Models) > 0, "a switching model needs a process model");
 
    static_assert(
        ((isFixedStep<Models> || isUnboundStep<Models>) && ...)
            || ((!isFixedStep<Models> && !isUnboundStep<Models>) && ...),
        "a switching model's process models are all fixed-step or none are"
    );
 
public:
 
    using Scalar = Scalar_;                              
    using ModeSpaceType = ModeSpace_;                    
    using ChainType = MarkovChain<ModeSpace_, Scalar_>;  

    static constexpr bool Shared = sizeof...(Models) == 1 && std::is_same_v<Path_, ModeSpace_>;

    SwitchingModel(ChainType chain, Models... models)
        : m_chain{std::move(chain)}
        , m_models{std::move(models)...}
    {
        if constexpr ((isFixedStep<Models> && ...))
        {
            EMRYS_FILTER_ASSERT(
                std::apply(
                    [](auto const & first, auto const &... rest) {
                        return ((rest.timeStep() == first.timeStep()) && ...);
                    },
                    m_models
                )
                && "a switching model's fixed-step models must share one step"
            );
        }
        if constexpr (!Shared)
        {
            using Axis = internal::PathTag<Path_>;
            static_assert(
                Axis::Cardinality == Eigen::Dynamic || Axis::Cardinality == int(sizeof...(Models)),
                "give one process model per value of the axis that selects it, "
                "or no path for one model shared by every mode"
            );
            EMRYS_FILTER_ASSERT(
                selector().cardinality == Eigen::Index(sizeof...(Models))
                && "give one process model per value of the axis that selects it, "
                   "or no path for one model shared by every mode"
            );
        }
    }

    template <typename... Others>
        requires(
            sizeof...(Others) == sizeof...(Models) && !(std::is_same_v<Others, Models> && ...)
            && (std::is_convertible_v<Others const &, Models> && ...)
        )
    SwitchingModel(SwitchingModel<ModeSpace_, Scalar_, Path_, Others...> const & other)
        : SwitchingModel{other, std::index_sequence_for<Models...>{}}
    {}

    [[nodiscard]] ChainType const &
    chain() const
    {
        return m_chain;
    }

    [[nodiscard]] ChainType &
    chain()
    {
        return m_chain;
    }

    [[nodiscard]] ModeSpace_ const &
    modeSpace() const
    {
        return m_chain.space();
    }

    template <std::size_t I>
    [[nodiscard]] auto const &
    model() const
    {
        return internal::modeModel(std::get<I>(m_models));
    }

    template <std::size_t I>
    [[nodiscard]] auto &
    model()
    {
        return internal::modeModel(std::get<I>(m_models));
    }

    [[nodiscard]] std::size_t
    modelIndex(Eigen::Index mode) const
    {
        EMRYS_FILTER_ASSERT(mode >= 0 && mode < modeSpace().cardinality() && "the mode is out of range");
        if constexpr (Shared)
        {
            return 0;
        }
        else
        {
            auto const location = selector();
            return std::size_t((mode / location.stride) % location.cardinality);
        }
    }

    template <typename F>
    decltype(auto)
    visit(Eigen::Index mode, F && f) const
    {
        return visitEntry(mode, [&](auto const & entry) -> decltype(auto) {
            return f(internal::modeModel(entry));
        });
    }

    template <typename Fallback, typename F>
    decltype(auto)
    visit(Eigen::Index mode, Fallback const & fallback, F && f) const
    {
        return visitEntry(mode, [&](auto const & entry) -> decltype(auto) {
            return f(internal::modeModel(entry), internal::modeMethod(entry, fallback));
        });
    }

    template <typename Space>
    [[nodiscard]] static consteval internal::StaticPartition
    staticPartition()
    {
        using internal::StaticPartition;
        constexpr auto each = std::array<StaticPartition, sizeof...(Models)>{
            internal::staticPartition<internal::ModeModel<Models>, Space>()...
        };
        if (std::ranges::find(each, StaticPartition::fails) != each.end())
        {
            return StaticPartition::fails;
        }
        return std::ranges::all_of(
                   each,
                   [](StaticPartition p) {
                       return p == StaticPartition::holds;
                   }
               )
                 ? StaticPartition::holds
                 : StaticPartition::unknown;
    }

    template <typename Space>
    [[nodiscard]] bool
    partitions(Space const & space) const
    {
        return std::apply(
            [&](auto const &... models) {
                return (internal::modeModel(models).partitions(space) && ...);
            },
            m_models
        );
    }
 
private:

    template <typename F>
    decltype(auto)
    visitEntry(Eigen::Index mode, F const & f) const
    {
        std::size_t const index = modelIndex(mode);
        return [&]<std::size_t... I>(std::index_sequence<I...>) -> decltype(auto) {
            using Result = decltype(f(std::get<0>(m_models)));
            if constexpr (std::is_void_v<Result>)
            {
                ((I == index ? (void)f(std::get<I>(m_models)) : void()), ...);
            }
            else
            {
                auto result = Result{};
                ((I == index ? (void)(result = f(std::get<I>(m_models))) : void()), ...);
                return result;
            }
        }(std::index_sequence_for<Models...>{});
    }

    template <typename Other, std::size_t... I>
    SwitchingModel(Other const & other, std::index_sequence<I...>)
        : SwitchingModel{other.chain(), Models(other.template model<I>())...}
    {}

    struct Selector
    {
        Eigen::Index stride;       
        Eigen::Index cardinality;  
    };

    [[nodiscard]] Selector
    selector() const
    {
        auto const [stride, axis] = internal::locateAxisByPath<Path_>(modeSpace());
        return {stride, axis->cardinality()};
    }
 
    ChainType m_chain;               
    std::tuple<Models...> m_models;  
};

template <typename ModeSpace_, typename Scalar_, typename Path_, typename... Models>
inline constexpr bool isFixedStep<SwitchingModel<ModeSpace_, Scalar_, Path_, Models...>>{(isFixedStep<Models> && ...)};
 
namespace internal
{

template <typename ModeSpace_, typename Scalar_, typename Path_, typename First, typename... Rest>
struct DefaultMethodOf<SwitchingModel<ModeSpace_, Scalar_, Path_, First, Rest...>>
{
    using type = std::conditional_t<isFixedStep<First> || isUnboundStep<First>, ModelsMethod, methods::Linearized>;
};

template <typename ModeSpace_, typename Scalar_, typename Path_, typename... Models>
[[nodiscard]] ModelsMethod
predictionMethod(SwitchingModel<ModeSpace_, Scalar_, Path_, Models...> const &, ModelsMethod method)
{
    return method;
}

template <typename ModeSpace_, typename Scalar_, typename Path_, typename... Models, typename Space, typename Scalar>
struct BoundStepOf<SwitchingModel<ModeSpace_, Scalar_, Path_, Models...>, Space, Scalar>
{
    using type = SwitchingModel<ModeSpace_, Scalar_, Path_, BoundStep<Models, Space, Scalar>...>;  
};

template <typename ModeSpace_, typename Scalar_, typename Path_, typename... Models, typename Method>
inline constexpr bool predictsBy<SwitchingModel<ModeSpace_, Scalar_, Path_, Models...>, Method>{
    !isFixedStep<SwitchingModel<ModeSpace_, Scalar_, Path_, Models...>> || std::is_same_v<Method, ModelsMethod>
};
 
}  // namespace internal

template <typename ModeSpace, typename Scalar, typename... Models>
SwitchingModel(MarkovChain<ModeSpace, Scalar>, Models...) -> SwitchingModel<ModeSpace, Scalar, ModeSpace, Models...>;


template <typename P, typename ModeSpace, typename Scalar, typename... Models>
[[nodiscard]] SwitchingModel<ModeSpace, Scalar, P, Models...>
switchingModel(MarkovChain<ModeSpace, Scalar> chain, Models... models)
{
    return {std::move(chain), std::move(models)...};
}

template <typename Path_, Measurement... Measurements>
class SwitchingMeasurement
{
    static_assert(sizeof...(Measurements) > 0, "a switching measurement needs a measurement");
 
public:
 
    using PathType = Path_;  
 
    static constexpr std::size_t Count = sizeof...(Measurements);  

    template <std::size_t I>
    using MeasurementType = std::tuple_element_t<I, std::tuple<Measurements...>>;

    explicit SwitchingMeasurement(Measurements... measurements)
        : m_measurements{std::move(measurements)...}
    {
        using Axis = internal::PathTag<Path_>;
        static_assert(
            Axis::Cardinality == Eigen::Dynamic || Axis::Cardinality == int(sizeof...(Measurements)),
            "give one measurement per value of the axis that selects it"
        );
    }

    template <std::size_t I>
    [[nodiscard]] MeasurementType<I> const &
    measurement() const
    {
        return std::get<I>(m_measurements);
    }

    template <typename F>
    decltype(auto)
    visit(std::size_t value, F && f) const
    {
        EMRYS_FILTER_ASSERT(value < Count && "the switching measurement has no measurement for this value of the axis");
        return visitFrom<0>(value, f);
    }
 
private:

    template <std::size_t I, typename F>
    decltype(auto)
    visitFrom(std::size_t value, F & f) const
    {
        if constexpr (I + 1 == Count)
        {
            return f(std::get<I>(m_measurements));
        }
        else
        {
            if (value == I)
            {
                return f(std::get<I>(m_measurements));
            }
            return visitFrom<I + 1>(value, f);
        }
    }
 
    std::tuple<Measurements...> m_measurements;  
};

template <typename P, Measurement... Measurements>
[[nodiscard]] SwitchingMeasurement<P, Measurements...>
switchingMeasurement(Measurements... measurements)
{
    return SwitchingMeasurement<P, Measurements...>{std::move(measurements)...};
}
 
namespace internal
{

template <typename T>
inline constexpr bool isSwitchingMeasurement = false;

template <typename Path, typename... Measurements>
inline constexpr bool isSwitchingMeasurement<SwitchingMeasurement<Path, Measurements...>> = true;

 
}  // namespace internal
 
}  // namespace Emrys