AmmFilter.h

Go to the documentation of this file.

#pragma once

 
#include <concepts>
#include <utility>
 
#include <EmrysFilter/Core/Allocation.h>
#include <EmrysFilter/Core/Print.h>
#include <EmrysFilter/Distributions/Categorical.h>
#include <EmrysFilter/Distributions/Component.h>
#include <EmrysFilter/Distributions/Hybrid.h>
#include <EmrysFilter/Filters/ImmFilter.h>
#include <EmrysFilter/Models/ProcessModel.h>
#include <EmrysFilter/Models/SwitchingModel.h>
 
namespace Emrys
{

template <
    Component Component_,
    typename Model_,
    typename Method_ = DefaultMethodFor<Model_>,
    typename Allocator_ = DefaultAllocator,
    typename Upkeep_ = upkeep::None>
class AmmFilter : public ImmFilter<Component_, Model_, Method_, Allocator_, Upkeep_>
{
public:
 
    using Base = ImmFilter<Component_, Model_, Method_, Allocator_, Upkeep_>;  

    template <typename... Models>
        requires std::constructible_from<Model_, typename Model_::ChainType, Models...>
    AmmFilter(typename Base::StateType state, Models... models)
        // The braces sequence the arguments, so the chain copies the modes before the state moves.
        : Base{Model_{typename Model_::ChainType{state.modeSpace()}, std::move(models)...}, std::move(state)}
    {}

    template <typename... Models>
        requires(!isFixedStep<Model_> && std::constructible_from<Model_, typename Model_::ChainType, Models...>)
    AmmFilter(Method_ method, typename Base::StateType state, Models... models)
        : Base{
              Model_{typename Model_::ChainType{state.modeSpace()}, std::move(models)...},
              std::move(state),
              std::move(method)
          }
    {}

    template <typename... Models>
        requires(
            !std::same_as<Upkeep_, Emrys::upkeep::None>
            && std::constructible_from<Model_, typename Model_::ChainType, Models...>
        )
    AmmFilter(std::type_identity_t<Upkeep_> upkeep, typename Base::StateType state, Models... models)
        : Base{
              Model_{typename Model_::ChainType{state.modeSpace()}, std::move(models)...},
              std::move(state),
              MethodFor<Model_, Method_>{},
              std::move(upkeep)
          }
    {}

    template <typename... Models>
        requires(
            !isFixedStep<Model_> && !std::same_as<Upkeep_, Emrys::upkeep::None>
            && std::constructible_from<Model_, typename Model_::ChainType, Models...>
        )
    AmmFilter(Method_ method, std::type_identity_t<Upkeep_> upkeep, typename Base::StateType state, Models... models)
        : Base{
              Model_{typename Model_::ChainType{state.modeSpace()}, std::move(models)...},
              std::move(state),
              std::move(method),
              std::move(upkeep)
          }
    {}
};

template <Component C, typename ModeSpace, typename Allocator, typename... Models>
AmmFilter(HybridParams<C, ModeSpace, Allocator>, Models...) -> AmmFilter<
    C,
    SwitchingModel<
        ModeSpace,
        typename C::Scalar,
        ModeSpace,
        internal::BoundStep<Models, typename Params<C>::SpaceType, typename Params<C>::Scalar>...>,
    DefaultMethodFor<SwitchingModel<ModeSpace, typename C::Scalar, ModeSpace, Models...>>,
    Allocator>;
 
template <typename Method, Component C, typename ModeSpace, typename Allocator, typename... Models>
    requires(!internal::UpkeepArgument<Method>)
AmmFilter(Method, HybridParams<C, ModeSpace, Allocator>, Models...) -> AmmFilter<
    C,
    SwitchingModel<
        ModeSpace,
        typename C::Scalar,
        ModeSpace,
        internal::BoundStep<Models, typename Params<C>::SpaceType, typename Params<C>::Scalar>...>,
    Method,
    Allocator>;
 
template <typename U, Component C, typename ModeSpace, typename Allocator, typename... Models>
    requires internal::UpkeepArgument<U>
AmmFilter(U, HybridParams<C, ModeSpace, Allocator>, Models...) -> AmmFilter<
    C,
    SwitchingModel<
        ModeSpace,
        typename C::Scalar,
        ModeSpace,
        internal::BoundStep<Models, typename Params<C>::SpaceType, typename Params<C>::Scalar>...>,
    DefaultMethodFor<SwitchingModel<ModeSpace, typename C::Scalar, ModeSpace, Models...>>,
    Allocator,
    U>;
 
template <typename Method, typename U, Component C, typename ModeSpace, typename Allocator, typename... Models>
AmmFilter(Method, U, HybridParams<C, ModeSpace, Allocator>, Models...) -> AmmFilter<
    C,
    SwitchingModel<
        ModeSpace,
        typename C::Scalar,
        ModeSpace,
        internal::BoundStep<Models, typename Params<C>::SpaceType, typename Params<C>::Scalar>...>,
    Method,
    Allocator,
    U>;
 
}  // namespace Emrys
 
#ifndef EMRYS_FILTER_NO_IO
 
namespace Emrys
{
 
namespace internal
{

template <typename Component_, typename Model_, typename Method_, typename Allocator_, typename Upkeep_>
void
describe(
    std::ostream & stream,
    AmmFilter<Component_, Model_, Method_, Allocator_, Upkeep_> const & filter,
    Indent indent
)
{
    describeFilter(stream, "autonomous multiple model filter", filter.state(), indent);
}
 
}  // namespace internal
 
}  // namespace Emrys
 
#endif  // EMRYS_FILTER_NO_IO